From 90ac61067f8bf773ca5c35ca5b10a2f7d0820c4e Mon Sep 17 00:00:00 2001 From: OMGeeky Date: Sat, 21 Oct 2023 02:11:31 +0200 Subject: [PATCH] make regen-apis --- gen/abusiveexperiencereport1/src/api.rs | 6 +-- gen/abusiveexperiencereport1/src/lib.rs | 32 ++++++------- gen/acceleratedmobilepageurl1/src/api.rs | 6 +-- gen/acceleratedmobilepageurl1/src/lib.rs | 32 ++++++------- gen/accessapproval1/src/lib.rs | 32 ++++++------- gen/accessapproval1_beta1/src/lib.rs | 32 ++++++------- gen/accesscontextmanager1/src/lib.rs | 32 ++++++------- gen/accesscontextmanager1_beta/src/lib.rs | 32 ++++++------- gen/adexchangebuyer1d3/src/lib.rs | 32 ++++++------- gen/adexchangebuyer1d4/src/lib.rs | 32 ++++++------- gen/adexchangebuyer2_v2_beta1/src/lib.rs | 32 ++++++------- gen/adexchangeseller2/src/lib.rs | 32 ++++++------- gen/adexperiencereport1/src/api.rs | 6 +-- gen/adexperiencereport1/src/lib.rs | 32 ++++++------- gen/admob1/src/lib.rs | 32 ++++++------- gen/adsense1d4/src/lib.rs | 32 ++++++------- gen/adsense2/src/lib.rs | 32 ++++++------- gen/adsensehost4d1/src/lib.rs | 32 ++++++------- gen/alertcenter1_beta1/src/lib.rs | 32 ++++++------- gen/analytics3/src/lib.rs | 32 ++++++------- gen/analyticsadmin1_alpha/src/lib.rs | 32 ++++++------- gen/analyticsdata1_beta/src/lib.rs | 32 ++++++------- gen/analyticsreporting4/src/lib.rs | 32 ++++++------- gen/androiddeviceprovisioning1/src/api.rs | 6 +-- gen/androiddeviceprovisioning1/src/lib.rs | 32 ++++++------- gen/androidenterprise1/src/lib.rs | 32 ++++++------- gen/androidmanagement1/src/lib.rs | 32 ++++++------- gen/androidpublisher2/src/lib.rs | 32 ++++++------- gen/androidpublisher3/src/lib.rs | 32 ++++++------- gen/apigateway1/src/lib.rs | 32 ++++++------- gen/apigee1/src/lib.rs | 32 ++++++------- gen/apikeys2/src/lib.rs | 32 ++++++------- gen/appengine1/src/lib.rs | 32 ++++++------- gen/appengine1_beta4/src/lib.rs | 32 ++++++------- gen/appengine1_beta5/src/lib.rs | 32 ++++++------- gen/appsactivity1/src/lib.rs | 32 ++++++------- gen/appstate1/src/lib.rs | 32 ++++++------- gen/area120tables1_alpha1/src/lib.rs | 32 ++++++------- gen/artifactregistry1/src/lib.rs | 32 ++++++------- gen/artifactregistry1_beta1/src/lib.rs | 32 ++++++------- gen/assuredworkloads1/src/lib.rs | 32 ++++++------- gen/authorizedbuyersmarketplace1/src/lib.rs | 32 ++++++------- gen/autoscaler1_beta2/src/lib.rs | 32 ++++++------- gen/baremetalsolution2/src/lib.rs | 32 ++++++------- gen/bigquery2/src/lib.rs | 32 ++++++------- gen/bigqueryconnection1_beta1/src/lib.rs | 32 ++++++------- gen/bigquerydatatransfer1/src/lib.rs | 32 ++++++------- gen/bigqueryreservation1/src/lib.rs | 32 ++++++------- gen/bigtableadmin2/src/lib.rs | 32 ++++++------- gen/billingbudgets1/src/lib.rs | 32 ++++++------- gen/billingbudgets1_beta1/src/lib.rs | 32 ++++++------- gen/binaryauthorization1/src/lib.rs | 32 ++++++------- gen/binaryauthorization1_beta1/src/lib.rs | 32 ++++++------- gen/blogger3/src/lib.rs | 32 ++++++------- gen/books1/src/lib.rs | 32 ++++++------- gen/calendar3/src/lib.rs | 32 ++++++------- gen/certificatemanager1/src/lib.rs | 32 ++++++------- gen/chromemanagement1/src/lib.rs | 32 ++++++------- gen/chromepolicy1/src/lib.rs | 32 ++++++------- gen/chromeuxreport1/src/api.rs | 6 +-- gen/chromeuxreport1/src/lib.rs | 32 ++++++------- gen/classroom1/src/lib.rs | 32 ++++++------- gen/cloudasset1/src/lib.rs | 32 ++++++------- gen/cloudasset1_beta1/src/lib.rs | 32 ++++++------- gen/cloudbilling1/src/lib.rs | 32 ++++++------- gen/cloudbuild1/src/lib.rs | 32 ++++++------- gen/cloudchannel1/src/lib.rs | 32 ++++++------- gen/clouddebugger2/src/lib.rs | 32 ++++++------- gen/clouddeploy1/src/lib.rs | 32 ++++++------- gen/clouderrorreporting1_beta1/src/lib.rs | 32 ++++++------- gen/cloudfunctions1/src/lib.rs | 32 ++++++------- gen/cloudidentity1/src/lib.rs | 32 ++++++------- gen/cloudiot1/src/lib.rs | 32 ++++++------- gen/cloudkms1/src/lib.rs | 32 ++++++------- gen/cloudkms1_beta1/src/lib.rs | 32 ++++++------- gen/cloudlatencytest2/src/lib.rs | 32 ++++++------- gen/cloudmonitoring2_beta2/src/lib.rs | 32 ++++++------- gen/cloudprivatecatalog1_beta1/src/lib.rs | 32 ++++++------- .../src/lib.rs | 32 ++++++------- gen/cloudprofiler2/src/lib.rs | 32 ++++++------- gen/cloudresourcemanager1/src/lib.rs | 32 ++++++------- gen/cloudresourcemanager1_beta1/src/lib.rs | 32 ++++++------- gen/cloudresourcemanager2/src/lib.rs | 32 ++++++------- gen/cloudresourcemanager3/src/lib.rs | 32 ++++++------- gen/cloudscheduler1/src/lib.rs | 32 ++++++------- gen/cloudscheduler1_beta1/src/lib.rs | 32 ++++++------- gen/cloudshell1/src/lib.rs | 32 ++++++------- gen/cloudsupport2_beta/src/lib.rs | 32 ++++++------- gen/cloudtasks2/src/lib.rs | 32 ++++++------- gen/cloudtasks2_beta2/src/lib.rs | 32 ++++++------- gen/cloudtasks2_beta3/src/lib.rs | 32 ++++++------- gen/cloudtrace1/src/lib.rs | 32 ++++++------- gen/cloudtrace2/src/lib.rs | 32 ++++++------- gen/clouduseraccountsvm_beta/src/lib.rs | 32 ++++++------- gen/commentanalyzer1_alpha1/src/lib.rs | 32 ++++++------- gen/composer1/src/lib.rs | 32 ++++++------- gen/compute1/src/lib.rs | 32 ++++++------- gen/connectors1/src/lib.rs | 32 ++++++------- gen/consumersurveys2/src/lib.rs | 32 ++++++------- gen/contactcenterinsights1/src/lib.rs | 32 ++++++------- gen/container1/src/lib.rs | 32 ++++++------- gen/containeranalysis1/src/lib.rs | 32 ++++++------- gen/containeranalysis1_beta1/src/lib.rs | 32 ++++++------- gen/content2/src/lib.rs | 32 ++++++------- gen/content2_sandbox/src/lib.rs | 32 ++++++------- gen/coordinate1/src/lib.rs | 32 ++++++------- gen/customsearch1/src/api.rs | 6 +-- gen/customsearch1/src/lib.rs | 32 ++++++------- gen/datacatalog1/src/lib.rs | 32 ++++++------- gen/datacatalog1_beta1/src/lib.rs | 32 ++++++------- gen/datafusion1/src/lib.rs | 32 ++++++------- gen/datafusion1_beta1/src/lib.rs | 32 ++++++------- gen/datalabeling1_beta1/src/lib.rs | 32 ++++++------- gen/datamigration1/src/lib.rs | 32 ++++++------- gen/datapipelines1/src/lib.rs | 32 ++++++------- gen/dataplex1/src/lib.rs | 32 ++++++------- gen/dataproc1/src/lib.rs | 32 ++++++------- gen/datastore1/src/lib.rs | 32 ++++++------- gen/datastore1_beta3/src/lib.rs | 32 ++++++------- gen/datastream1/src/lib.rs | 32 ++++++------- gen/deploymentmanager2/src/lib.rs | 32 ++++++------- gen/deploymentmanager2_beta2/src/lib.rs | 32 ++++++------- gen/dfareporting2d8/src/lib.rs | 32 ++++++------- gen/dfareporting3/src/lib.rs | 32 ++++++------- gen/dfareporting3d2/src/lib.rs | 32 ++++++------- gen/dfareporting3d3/src/lib.rs | 32 ++++++------- gen/dfareporting3d4/src/lib.rs | 32 ++++++------- gen/dfareporting3d5/src/lib.rs | 32 ++++++------- gen/dialogflow2/src/lib.rs | 32 ++++++------- gen/dialogflow2_beta1/src/lib.rs | 32 ++++++------- gen/dialogflow3/src/lib.rs | 32 ++++++------- gen/digitalassetlinks1/src/api.rs | 6 +-- gen/digitalassetlinks1/src/lib.rs | 32 ++++++------- gen/discovery1/src/api.rs | 6 +-- gen/discovery1/src/lib.rs | 32 ++++++------- gen/displayvideo1/src/lib.rs | 32 ++++++------- gen/dlp2/src/lib.rs | 32 ++++++------- gen/dlp2_beta1/src/lib.rs | 32 ++++++------- gen/dns1/src/lib.rs | 32 ++++++------- gen/dns2/src/lib.rs | 32 ++++++------- gen/docs1/src/lib.rs | 32 ++++++------- gen/documentai1/src/lib.rs | 32 ++++++------- gen/documentai1_beta2/src/lib.rs | 32 ++++++------- gen/domains1/src/lib.rs | 32 ++++++------- gen/domains1_beta1/src/lib.rs | 32 ++++++------- gen/domainsrdap1/src/api.rs | 6 +-- gen/domainsrdap1/src/lib.rs | 32 ++++++------- gen/doubleclickbidmanager1/src/lib.rs | 32 ++++++------- gen/doubleclickbidmanager1d1/src/lib.rs | 32 ++++++------- gen/doubleclicksearch2/src/lib.rs | 32 ++++++------- gen/drive2/src/lib.rs | 32 ++++++------- gen/drive3/src/lib.rs | 32 ++++++------- gen/driveactivity2/src/lib.rs | 32 ++++++------- gen/essentialcontacts1/src/lib.rs | 32 ++++++------- gen/eventarc1/src/lib.rs | 32 ++++++------- gen/factchecktools1_alpha1/src/lib.rs | 32 ++++++------- gen/fcm1/src/lib.rs | 32 ++++++------- gen/fcmdata1_beta1/src/lib.rs | 32 ++++++------- gen/file1/src/lib.rs | 32 ++++++------- gen/file1_beta1/src/lib.rs | 32 ++++++------- gen/firebase1_beta1/src/lib.rs | 32 ++++++------- gen/firebaseappcheck1_beta/src/lib.rs | 32 ++++++------- gen/firebasedatabase1_beta/src/lib.rs | 32 ++++++------- gen/firebasedynamiclinks1/src/lib.rs | 32 ++++++------- gen/firebasehosting1/src/api.rs | 6 +-- gen/firebasehosting1/src/lib.rs | 32 ++++++------- gen/firebasehosting1_beta1/src/lib.rs | 32 ++++++------- gen/firebaseml1/src/lib.rs | 32 ++++++------- gen/firebaseremoteconfig1/src/api.rs | 6 +-- gen/firebaseremoteconfig1/src/lib.rs | 32 ++++++------- gen/firebasestorage1_beta/src/lib.rs | 32 ++++++------- gen/firestore1/src/lib.rs | 32 ++++++------- gen/firestore1_beta1/src/lib.rs | 32 ++++++------- gen/fitness1/src/lib.rs | 32 ++++++------- gen/fusiontables2/src/lib.rs | 32 ++++++------- gen/games1/src/lib.rs | 32 ++++++------- .../src/lib.rs | 32 ++++++------- gen/gameservices1/src/lib.rs | 32 ++++++------- gen/gamesmanagement1_management/src/lib.rs | 32 ++++++------- gen/gan1_beta1/src/api.rs | 6 +-- gen/gan1_beta1/src/lib.rs | 32 ++++++------- gen/genomics1/src/lib.rs | 32 ++++++------- gen/gkehub1/src/lib.rs | 32 ++++++------- gen/gmail1/src/lib.rs | 32 ++++++------- gen/gmailpostmastertools1/src/lib.rs | 32 ++++++------- gen/gmailpostmastertools1_beta1/src/lib.rs | 32 ++++++------- gen/groupsmigration1/src/lib.rs | 32 ++++++------- gen/groupssettings1/src/lib.rs | 32 ++++++------- gen/healthcare1/src/lib.rs | 32 ++++++------- gen/healthcare1_beta1/src/lib.rs | 32 ++++++------- gen/iam1/src/lib.rs | 32 ++++++------- gen/iamcredentials1/src/lib.rs | 32 ++++++------- gen/iap1/src/lib.rs | 32 ++++++------- gen/iap1_beta1/src/lib.rs | 32 ++++++------- gen/ideahub1_beta/src/api.rs | 6 +-- gen/ideahub1_beta/src/lib.rs | 32 ++++++------- gen/identitytoolkit3/src/lib.rs | 32 ++++++------- gen/ids1/src/lib.rs | 32 ++++++------- gen/indexing3/src/lib.rs | 32 ++++++------- gen/jobs3/src/lib.rs | 32 ++++++------- gen/jobs4/src/lib.rs | 32 ++++++------- gen/keep1/src/lib.rs | 32 ++++++------- gen/language1/src/lib.rs | 32 ++++++------- gen/language1_beta1/src/lib.rs | 32 ++++++------- gen/libraryagent1/src/lib.rs | 32 ++++++------- gen/licensing1/src/lib.rs | 32 ++++++------- gen/lifesciences2_beta/src/lib.rs | 32 ++++++------- gen/localservices1/src/lib.rs | 32 ++++++------- gen/logging2/src/lib.rs | 32 ++++++------- gen/logging2_beta1/src/lib.rs | 32 ++++++------- gen/managedidentities1/src/lib.rs | 32 ++++++------- gen/manager1_beta2/src/lib.rs | 32 ++++++------- gen/manufacturers1/src/lib.rs | 32 ++++++------- gen/memcache1/src/lib.rs | 32 ++++++------- gen/memcache1_beta2/src/lib.rs | 32 ++++++------- gen/metastore1_beta/src/lib.rs | 32 ++++++------- gen/mirror1/src/lib.rs | 32 ++++++------- gen/ml1/src/lib.rs | 32 ++++++------- gen/monitoring3/src/lib.rs | 32 ++++++------- gen/mybusiness4/src/api.rs | 6 +-- gen/mybusiness4/src/lib.rs | 32 ++++++------- gen/mybusinessaccountmanagement1/src/api.rs | 6 +-- gen/mybusinessaccountmanagement1/src/lib.rs | 32 ++++++------- gen/mybusinessbusinesscalls1/src/api.rs | 6 +-- gen/mybusinessbusinesscalls1/src/lib.rs | 32 ++++++------- gen/mybusinessbusinessinformation1/src/api.rs | 6 +-- gen/mybusinessbusinessinformation1/src/lib.rs | 32 ++++++------- gen/mybusinesslodging1/src/api.rs | 6 +-- gen/mybusinesslodging1/src/lib.rs | 32 ++++++------- gen/mybusinessnotifications1/src/api.rs | 6 +-- gen/mybusinessnotifications1/src/lib.rs | 32 ++++++------- gen/mybusinessplaceactions1/src/api.rs | 6 +-- gen/mybusinessplaceactions1/src/lib.rs | 32 ++++++------- gen/mybusinessverifications1/src/api.rs | 6 +-- gen/mybusinessverifications1/src/lib.rs | 32 ++++++------- gen/networkconnectivity1/src/lib.rs | 32 ++++++------- gen/networkconnectivity1_alpha1/src/lib.rs | 32 ++++++------- gen/networkmanagement1/src/lib.rs | 32 ++++++------- gen/networksecurity1/src/lib.rs | 32 ++++++------- gen/networkservices1/src/lib.rs | 32 ++++++------- gen/notebooks1/src/lib.rs | 32 ++++++------- gen/ondemandscanning1/src/lib.rs | 32 ++++++------- gen/orgpolicy2/src/lib.rs | 32 ++++++------- gen/oslogin1/src/lib.rs | 32 ++++++------- gen/oslogin1_beta/src/lib.rs | 32 ++++++------- gen/pagespeedonline2/src/api.rs | 6 +-- gen/pagespeedonline2/src/lib.rs | 32 ++++++------- gen/pagespeedonline4/src/api.rs | 6 +-- gen/pagespeedonline4/src/lib.rs | 32 ++++++------- gen/pagespeedonline5/src/lib.rs | 32 ++++++------- gen/partners2/src/api.rs | 6 +-- gen/partners2/src/lib.rs | 32 ++++++------- gen/paymentsresellersubscription1/src/api.rs | 6 +-- gen/paymentsresellersubscription1/src/lib.rs | 32 ++++++------- gen/people1/src/lib.rs | 32 ++++++------- gen/photoslibrary1/src/lib.rs | 32 ++++++------- gen/playablelocations3/src/api.rs | 6 +-- gen/playablelocations3/src/lib.rs | 32 ++++++------- gen/playcustomapp1/src/lib.rs | 32 ++++++------- gen/playintegrity1/src/lib.rs | 32 ++++++------- gen/playmoviespartner1/src/lib.rs | 32 ++++++------- gen/plus1/src/lib.rs | 32 ++++++------- gen/plusdomains1/src/lib.rs | 32 ++++++------- gen/policyanalyzer1/src/lib.rs | 32 ++++++------- gen/policysimulator1/src/lib.rs | 32 ++++++------- gen/policytroubleshooter1/src/lib.rs | 32 ++++++------- gen/prediction1d6/src/lib.rs | 32 ++++++------- gen/privateca1/src/lib.rs | 32 ++++++------- gen/privateca1_beta1/src/lib.rs | 32 ++++++------- gen/prod_tt_sasportal1_alpha1/src/lib.rs | 32 ++++++------- gen/proximitybeacon1_beta1/src/lib.rs | 32 ++++++------- gen/pubsub1/src/lib.rs | 32 ++++++------- gen/pubsub1_beta2/src/lib.rs | 32 ++++++------- gen/pubsublite1/src/lib.rs | 32 ++++++------- gen/qpxexpress1/src/api.rs | 6 +-- gen/qpxexpress1/src/lib.rs | 32 ++++++------- gen/realtimebidding1/src/lib.rs | 32 ++++++------- gen/recaptchaenterprise1/src/lib.rs | 32 ++++++------- gen/recommendationengine1_beta1/src/lib.rs | 32 ++++++------- gen/recommender1/src/lib.rs | 32 ++++++------- gen/recommender1_beta1/src/lib.rs | 32 ++++++------- gen/redis1/src/lib.rs | 32 ++++++------- gen/remotebuildexecution2/src/lib.rs | 32 ++++++------- gen/replicapool1_beta2/src/lib.rs | 32 ++++++------- gen/replicapoolupdater1_beta1/src/lib.rs | 32 ++++++------- gen/reseller1_sandbox/src/lib.rs | 32 ++++++------- gen/resourcesettings1/src/lib.rs | 32 ++++++------- gen/resourceviews1_beta2/src/lib.rs | 32 ++++++------- gen/retail2/src/lib.rs | 32 ++++++------- gen/run1/src/lib.rs | 32 ++++++------- gen/run2/src/lib.rs | 32 ++++++------- gen/runtimeconfig1/src/lib.rs | 32 ++++++------- gen/runtimeconfig1_beta1/src/lib.rs | 32 ++++++------- gen/safebrowsing4/src/api.rs | 6 +-- gen/safebrowsing4/src/lib.rs | 32 ++++++------- gen/sasportal1_alpha1/src/lib.rs | 32 ++++++------- gen/searchconsole1/src/lib.rs | 32 ++++++------- gen/secretmanager1/src/lib.rs | 32 ++++++------- gen/secretmanager1_beta1/src/lib.rs | 32 ++++++------- gen/securitycenter1/src/lib.rs | 32 ++++++------- gen/servicebroker1/src/lib.rs | 32 ++++++------- gen/servicecontrol1/src/lib.rs | 32 ++++++------- gen/servicecontrol2/src/lib.rs | 32 ++++++------- gen/servicedirectory1/src/lib.rs | 32 ++++++------- gen/servicedirectory1_beta1/src/lib.rs | 32 ++++++------- gen/serviceregistryalpha/src/lib.rs | 32 ++++++------- gen/sheets4/src/lib.rs | 32 ++++++------- gen/siteverification1/src/lib.rs | 32 ++++++------- gen/smartdevicemanagement1/src/lib.rs | 32 ++++++------- gen/sourcerepo1/src/lib.rs | 32 ++++++------- gen/spectrum1_explorer/src/api.rs | 6 +-- gen/spectrum1_explorer/src/lib.rs | 32 ++++++------- gen/speech1/src/lib.rs | 32 ++++++------- gen/speech1_beta1/src/lib.rs | 32 ++++++------- gen/sql1_beta4/src/lib.rs | 32 ++++++------- gen/sqladmin1/src/lib.rs | 32 ++++++------- gen/sqladmin1_beta4/src/lib.rs | 32 ++++++------- gen/storage1/src/lib.rs | 32 ++++++------- gen/storagetransfer1/src/lib.rs | 32 ++++++------- gen/sts1/src/api.rs | 6 +-- gen/sts1/src/lib.rs | 32 ++++++------- gen/surveys2/src/lib.rs | 32 ++++++------- gen/tagmanager1/src/lib.rs | 32 ++++++------- gen/tagmanager2/src/lib.rs | 32 ++++++------- gen/taskqueue1_beta2/src/lib.rs | 32 ++++++------- gen/tasks1/src/lib.rs | 32 ++++++------- gen/testing1/src/lib.rs | 32 ++++++------- gen/texttospeech1/src/lib.rs | 32 ++++++------- gen/tpu1/src/lib.rs | 32 ++++++------- gen/tpu1_alpha1/src/lib.rs | 32 ++++++------- gen/transcoder1/src/lib.rs | 32 ++++++------- gen/transcoder1_beta1/src/lib.rs | 32 ++++++------- gen/translate2/src/lib.rs | 32 ++++++------- gen/translate3/src/lib.rs | 32 ++++++------- gen/urlshortener1/src/lib.rs | 32 ++++++------- gen/vault1/src/lib.rs | 32 ++++++------- gen/vectortile1/src/api.rs | 6 +-- gen/vectortile1/src/lib.rs | 32 ++++++------- gen/verifiedaccess1/src/lib.rs | 32 ++++++------- gen/versionhistory1/src/api.rs | 6 +-- gen/versionhistory1/src/lib.rs | 32 ++++++------- gen/videointelligence1/src/lib.rs | 32 ++++++------- gen/videointelligence1_beta1/src/lib.rs | 32 ++++++------- gen/vision1/src/lib.rs | 32 ++++++------- gen/vmmigration1/src/lib.rs | 32 ++++++------- gen/walletobjects1/src/lib.rs | 32 ++++++------- gen/webfonts1/src/api.rs | 6 +-- gen/webfonts1/src/lib.rs | 32 ++++++------- gen/webmasters3/src/lib.rs | 32 ++++++------- gen/webrisk1/src/lib.rs | 32 ++++++------- gen/workflowexecutions1/src/lib.rs | 32 ++++++------- gen/workflows1/src/lib.rs | 32 ++++++------- gen/youtube3/src/api.rs | 6 +-- gen/youtube3/src/lib.rs | 32 ++++++------- gen/youtubereporting1/src/lib.rs | 32 ++++++------- src/generator/templates/api/lib/lib.mako | 46 +++++++++---------- 356 files changed, 5261 insertions(+), 5261 deletions(-) diff --git a/gen/abusiveexperiencereport1/src/api.rs b/gen/abusiveexperiencereport1/src/api.rs index 4ef955f9d5..2bd245491b 100644 --- a/gen/abusiveexperiencereport1/src/api.rs +++ b/gen/abusiveexperiencereport1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use abusiveexperiencereport1::{AbusiveExperienceReport, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/abusiveexperiencereport1/src/lib.rs b/gen/abusiveexperiencereport1/src/lib.rs index 2ea1a358bc..6033bd9e71 100644 --- a/gen/abusiveexperiencereport1/src/lib.rs +++ b/gen/abusiveexperiencereport1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/abusiveexperiencereport1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AbusiveExperienceReport) ... +//! Handle the following *Resources* with ease from the central [hub](AbusiveExperienceReport) ... //! //! * sites //! * [*get*](api::SiteGetCall) @@ -52,8 +52,8 @@ //! let r = hub.sites().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use abusiveexperiencereport1::{AbusiveExperienceReport, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -122,10 +122,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -135,25 +135,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/acceleratedmobilepageurl1/src/api.rs b/gen/acceleratedmobilepageurl1/src/api.rs index 98f532b846..d8b890e418 100644 --- a/gen/acceleratedmobilepageurl1/src/api.rs +++ b/gen/acceleratedmobilepageurl1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use acceleratedmobilepageurl1::{Acceleratedmobilepageurl, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/acceleratedmobilepageurl1/src/lib.rs b/gen/acceleratedmobilepageurl1/src/lib.rs index 308b9e5802..21bd8777c1 100644 --- a/gen/acceleratedmobilepageurl1/src/lib.rs +++ b/gen/acceleratedmobilepageurl1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/acceleratedmobilepageurl1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Acceleratedmobilepageurl) ... +//! Handle the following *Resources* with ease from the central [hub](Acceleratedmobilepageurl) ... //! //! * [amp urls](api::AmpUrl) //! * [*batch get*](api::AmpUrlBatchGetCall) @@ -50,8 +50,8 @@ //! let r = hub.amp_urls().batch_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use acceleratedmobilepageurl1::{Acceleratedmobilepageurl, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/accessapproval1/src/lib.rs b/gen/accessapproval1/src/lib.rs index 2da1e49f4c..69a805ddf8 100644 --- a/gen/accessapproval1/src/lib.rs +++ b/gen/accessapproval1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/accessapproval1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AccessApproval) ... +//! Handle the following *Resources* with ease from the central [hub](AccessApproval) ... //! //! * folders //! * [*approval requests approve*](api::FolderApprovalRequestApproveCall), [*approval requests dismiss*](api::FolderApprovalRequestDismisCall), [*approval requests get*](api::FolderApprovalRequestGetCall), [*approval requests invalidate*](api::FolderApprovalRequestInvalidateCall), [*approval requests list*](api::FolderApprovalRequestListCall), [*delete access approval settings*](api::FolderDeleteAccessApprovalSettingCall), [*get access approval settings*](api::FolderGetAccessApprovalSettingCall), [*get service account*](api::FolderGetServiceAccountCall) and [*update access approval settings*](api::FolderUpdateAccessApprovalSettingCall) @@ -65,8 +65,8 @@ //! let r = hub.projects().approval_requests_invalidate(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -95,12 +95,12 @@ //! use std::default::Default; //! use accessapproval1::{AccessApproval, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/accessapproval1_beta1/src/lib.rs b/gen/accessapproval1_beta1/src/lib.rs index 066ecada6c..8c9e9de1ab 100644 --- a/gen/accessapproval1_beta1/src/lib.rs +++ b/gen/accessapproval1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/accessapproval1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AccessApproval) ... +//! Handle the following *Resources* with ease from the central [hub](AccessApproval) ... //! //! * folders //! * [*approval requests approve*](api::FolderApprovalRequestApproveCall), [*approval requests dismiss*](api::FolderApprovalRequestDismisCall), [*approval requests get*](api::FolderApprovalRequestGetCall), [*approval requests list*](api::FolderApprovalRequestListCall), [*delete access approval settings*](api::FolderDeleteAccessApprovalSettingCall), [*get access approval settings*](api::FolderGetAccessApprovalSettingCall) and [*update access approval settings*](api::FolderUpdateAccessApprovalSettingCall) @@ -62,8 +62,8 @@ //! let r = hub.projects().approval_requests_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use accessapproval1_beta1::{AccessApproval, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -138,10 +138,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -151,25 +151,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/accesscontextmanager1/src/lib.rs b/gen/accesscontextmanager1/src/lib.rs index 9512826641..8d2fed6a68 100644 --- a/gen/accesscontextmanager1/src/lib.rs +++ b/gen/accesscontextmanager1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/accesscontextmanager1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AccessContextManager) ... +//! Handle the following *Resources* with ease from the central [hub](AccessContextManager) ... //! //! * [access policies](api::AccessPolicy) //! * [*access levels create*](api::AccessPolicyAccessLevelCreateCall), [*access levels delete*](api::AccessPolicyAccessLevelDeleteCall), [*access levels get*](api::AccessPolicyAccessLevelGetCall), [*access levels list*](api::AccessPolicyAccessLevelListCall), [*access levels patch*](api::AccessPolicyAccessLevelPatchCall), [*access levels replace all*](api::AccessPolicyAccessLevelReplaceAllCall), [*access levels test iam permissions*](api::AccessPolicyAccessLevelTestIamPermissionCall), [*authorized orgs descs create*](api::AccessPolicyAuthorizedOrgsDescCreateCall), [*authorized orgs descs delete*](api::AccessPolicyAuthorizedOrgsDescDeleteCall), [*authorized orgs descs get*](api::AccessPolicyAuthorizedOrgsDescGetCall), [*authorized orgs descs list*](api::AccessPolicyAuthorizedOrgsDescListCall), [*authorized orgs descs patch*](api::AccessPolicyAuthorizedOrgsDescPatchCall), [*create*](api::AccessPolicyCreateCall), [*delete*](api::AccessPolicyDeleteCall), [*get*](api::AccessPolicyGetCall), [*get iam policy*](api::AccessPolicyGetIamPolicyCall), [*list*](api::AccessPolicyListCall), [*patch*](api::AccessPolicyPatchCall), [*service perimeters commit*](api::AccessPolicyServicePerimeterCommitCall), [*service perimeters create*](api::AccessPolicyServicePerimeterCreateCall), [*service perimeters delete*](api::AccessPolicyServicePerimeterDeleteCall), [*service perimeters get*](api::AccessPolicyServicePerimeterGetCall), [*service perimeters list*](api::AccessPolicyServicePerimeterListCall), [*service perimeters patch*](api::AccessPolicyServicePerimeterPatchCall), [*service perimeters replace all*](api::AccessPolicyServicePerimeterReplaceAllCall), [*service perimeters test iam permissions*](api::AccessPolicyServicePerimeterTestIamPermissionCall), [*set iam policy*](api::AccessPolicySetIamPolicyCall) and [*test iam permissions*](api::AccessPolicyTestIamPermissionCall) @@ -77,8 +77,8 @@ //! let r = hub.organizations().gcp_user_access_bindings_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -106,12 +106,12 @@ //! use std::default::Default; //! use accesscontextmanager1::{AccessContextManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -150,10 +150,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -163,25 +163,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/accesscontextmanager1_beta/src/lib.rs b/gen/accesscontextmanager1_beta/src/lib.rs index 7379cd3634..b882e7a778 100644 --- a/gen/accesscontextmanager1_beta/src/lib.rs +++ b/gen/accesscontextmanager1_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/accesscontextmanager1_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AccessContextManager) ... +//! Handle the following *Resources* with ease from the central [hub](AccessContextManager) ... //! //! * [access policies](api::AccessPolicy) //! * [*access levels create*](api::AccessPolicyAccessLevelCreateCall), [*access levels delete*](api::AccessPolicyAccessLevelDeleteCall), [*access levels get*](api::AccessPolicyAccessLevelGetCall), [*access levels list*](api::AccessPolicyAccessLevelListCall), [*access levels patch*](api::AccessPolicyAccessLevelPatchCall), [*create*](api::AccessPolicyCreateCall), [*delete*](api::AccessPolicyDeleteCall), [*get*](api::AccessPolicyGetCall), [*list*](api::AccessPolicyListCall), [*patch*](api::AccessPolicyPatchCall), [*service perimeters create*](api::AccessPolicyServicePerimeterCreateCall), [*service perimeters delete*](api::AccessPolicyServicePerimeterDeleteCall), [*service perimeters get*](api::AccessPolicyServicePerimeterGetCall), [*service perimeters list*](api::AccessPolicyServicePerimeterListCall) and [*service perimeters patch*](api::AccessPolicyServicePerimeterPatchCall) @@ -61,8 +61,8 @@ //! let r = hub.operations().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use accesscontextmanager1_beta::{AccessContextManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -138,10 +138,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -151,25 +151,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/adexchangebuyer1d3/src/lib.rs b/gen/adexchangebuyer1d3/src/lib.rs index 6de390ef60..8b70dba316 100644 --- a/gen/adexchangebuyer1d3/src/lib.rs +++ b/gen/adexchangebuyer1d3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/adexchangebuyer1d3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AdExchangeBuyer) ... +//! Handle the following *Resources* with ease from the central [hub](AdExchangeBuyer) ... //! //! * [accounts](api::Account) //! * [*get*](api::AccountGetCall), [*list*](api::AccountListCall), [*patch*](api::AccountPatchCall) and [*update*](api::AccountUpdateCall) @@ -65,8 +65,8 @@ //! let r = hub.pretargeting_config().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -95,12 +95,12 @@ //! use std::default::Default; //! use adexchangebuyer1d3::{AdExchangeBuyer, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/adexchangebuyer1d4/src/lib.rs b/gen/adexchangebuyer1d4/src/lib.rs index 42559434f3..2628823b9b 100644 --- a/gen/adexchangebuyer1d4/src/lib.rs +++ b/gen/adexchangebuyer1d4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/adexchangebuyer1d4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AdExchangeBuyer) ... +//! Handle the following *Resources* with ease from the central [hub](AdExchangeBuyer) ... //! //! * [accounts](api::Account) //! * [*get*](api::AccountGetCall), [*list*](api::AccountListCall), [*patch*](api::AccountPatchCall) and [*update*](api::AccountUpdateCall) @@ -77,8 +77,8 @@ //! let r = hub.creatives().remove_deal(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -106,12 +106,12 @@ //! use std::default::Default; //! use adexchangebuyer1d4::{AdExchangeBuyer, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -153,10 +153,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -166,25 +166,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/adexchangebuyer2_v2_beta1/src/lib.rs b/gen/adexchangebuyer2_v2_beta1/src/lib.rs index 1fa6f156c2..32caf0cf3b 100644 --- a/gen/adexchangebuyer2_v2_beta1/src/lib.rs +++ b/gen/adexchangebuyer2_v2_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/adexchangebuyer2_v2_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AdExchangeBuyerII) ... +//! Handle the following *Resources* with ease from the central [hub](AdExchangeBuyerII) ... //! //! * accounts //! * [*clients create*](api::AccountClientCreateCall), [*clients get*](api::AccountClientGetCall), [*clients invitations create*](api::AccountClientInvitationCreateCall), [*clients invitations get*](api::AccountClientInvitationGetCall), [*clients invitations list*](api::AccountClientInvitationListCall), [*clients list*](api::AccountClientListCall), [*clients update*](api::AccountClientUpdateCall), [*clients users get*](api::AccountClientUserGetCall), [*clients users list*](api::AccountClientUserListCall), [*clients users update*](api::AccountClientUserUpdateCall), [*creatives create*](api::AccountCreativeCreateCall), [*creatives deal associations add*](api::AccountCreativeDealAssociationAddCall), [*creatives deal associations list*](api::AccountCreativeDealAssociationListCall), [*creatives deal associations remove*](api::AccountCreativeDealAssociationRemoveCall), [*creatives get*](api::AccountCreativeGetCall), [*creatives list*](api::AccountCreativeListCall), [*creatives stop watching*](api::AccountCreativeStopWatchingCall), [*creatives update*](api::AccountCreativeUpdateCall), [*creatives watch*](api::AccountCreativeWatchCall), [*finalized proposals list*](api::AccountFinalizedProposalListCall), [*finalized proposals pause*](api::AccountFinalizedProposalPauseCall), [*finalized proposals resume*](api::AccountFinalizedProposalResumeCall), [*products get*](api::AccountProductGetCall), [*products list*](api::AccountProductListCall), [*proposals accept*](api::AccountProposalAcceptCall), [*proposals add note*](api::AccountProposalAddNoteCall), [*proposals cancel negotiation*](api::AccountProposalCancelNegotiationCall), [*proposals complete setup*](api::AccountProposalCompleteSetupCall), [*proposals create*](api::AccountProposalCreateCall), [*proposals get*](api::AccountProposalGetCall), [*proposals list*](api::AccountProposalListCall), [*proposals pause*](api::AccountProposalPauseCall), [*proposals resume*](api::AccountProposalResumeCall), [*proposals update*](api::AccountProposalUpdateCall), [*publisher profiles get*](api::AccountPublisherProfileGetCall) and [*publisher profiles list*](api::AccountPublisherProfileListCall) @@ -67,8 +67,8 @@ //! let r = hub.buyers().filter_sets_list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use adexchangebuyer2_v2_beta1::{AdExchangeBuyerII, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -139,10 +139,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -152,25 +152,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/adexchangeseller2/src/lib.rs b/gen/adexchangeseller2/src/lib.rs index ee7e071a65..2f42d45744 100644 --- a/gen/adexchangeseller2/src/lib.rs +++ b/gen/adexchangeseller2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/adexchangeseller2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AdExchangeSeller) ... +//! Handle the following *Resources* with ease from the central [hub](AdExchangeSeller) ... //! //! * [accounts](api::Account) //! * [*adclients list*](api::AccountAdclientListCall), [*alerts list*](api::AccountAlertListCall), [*customchannels get*](api::AccountCustomchannelGetCall), [*customchannels list*](api::AccountCustomchannelListCall), [*get*](api::AccountGetCall), [*list*](api::AccountListCall), [*metadata dimensions list*](api::AccountMetadataDimensionListCall), [*metadata metrics list*](api::AccountMetadataMetricListCall), [*preferreddeals get*](api::AccountPreferreddealGetCall), [*preferreddeals list*](api::AccountPreferreddealListCall), [*reports generate*](api::AccountReportGenerateCall), [*reports saved generate*](api::AccountReportSavedGenerateCall), [*reports saved list*](api::AccountReportSavedListCall) and [*urlchannels list*](api::AccountUrlchannelListCall) @@ -67,8 +67,8 @@ //! let r = hub.accounts().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use adexchangeseller2::{AdExchangeSeller, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -144,10 +144,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -157,25 +157,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/adexperiencereport1/src/api.rs b/gen/adexperiencereport1/src/api.rs index 51e51abfff..6f228431b9 100644 --- a/gen/adexperiencereport1/src/api.rs +++ b/gen/adexperiencereport1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use adexperiencereport1::{AdExperienceReport, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/adexperiencereport1/src/lib.rs b/gen/adexperiencereport1/src/lib.rs index 1a48de67ff..7e5fe3bc7b 100644 --- a/gen/adexperiencereport1/src/lib.rs +++ b/gen/adexperiencereport1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/adexperiencereport1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AdExperienceReport) ... +//! Handle the following *Resources* with ease from the central [hub](AdExperienceReport) ... //! //! * sites //! * [*get*](api::SiteGetCall) @@ -52,8 +52,8 @@ //! let r = hub.sites().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use adexperiencereport1::{AdExperienceReport, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -122,10 +122,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -135,25 +135,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/admob1/src/lib.rs b/gen/admob1/src/lib.rs index 47c95bf0a5..a099d13a6f 100644 --- a/gen/admob1/src/lib.rs +++ b/gen/admob1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/admob1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AdMob) ... +//! Handle the following *Resources* with ease from the central [hub](AdMob) ... //! //! * accounts //! * [*ad units list*](api::AccountAdUnitListCall), [*apps list*](api::AccountAppListCall), [*get*](api::AccountGetCall), [*list*](api::AccountListCall), [*mediation report generate*](api::AccountMediationReportGenerateCall) and [*network report generate*](api::AccountNetworkReportGenerateCall) @@ -50,8 +50,8 @@ //! let r = hub.accounts().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use admob1::{AdMob, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -120,10 +120,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -133,25 +133,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/adsense1d4/src/lib.rs b/gen/adsense1d4/src/lib.rs index 54f6e50214..9f6bb30de6 100644 --- a/gen/adsense1d4/src/lib.rs +++ b/gen/adsense1d4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/adsense1d4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AdSense) ... +//! Handle the following *Resources* with ease from the central [hub](AdSense) ... //! //! * [accounts](api::Account) //! * [*adclients get ad code*](api::AccountAdclientGetAdCodeCall), [*adclients list*](api::AccountAdclientListCall), [*adunits customchannels list*](api::AccountAdunitCustomchannelListCall), [*adunits get*](api::AccountAdunitGetCall), [*adunits get ad code*](api::AccountAdunitGetAdCodeCall), [*adunits list*](api::AccountAdunitListCall), [*alerts delete*](api::AccountAlertDeleteCall), [*alerts list*](api::AccountAlertListCall), [*customchannels adunits list*](api::AccountCustomchannelAdunitListCall), [*customchannels get*](api::AccountCustomchannelGetCall), [*customchannels list*](api::AccountCustomchannelListCall), [*get*](api::AccountGetCall), [*list*](api::AccountListCall), [*payments list*](api::AccountPaymentListCall), [*reports generate*](api::AccountReportGenerateCall), [*reports saved generate*](api::AccountReportSavedGenerateCall), [*reports saved list*](api::AccountReportSavedListCall), [*savedadstyles get*](api::AccountSavedadstyleGetCall), [*savedadstyles list*](api::AccountSavedadstyleListCall) and [*urlchannels list*](api::AccountUrlchannelListCall) @@ -92,8 +92,8 @@ //! let r = hub.accounts().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -121,12 +121,12 @@ //! use std::default::Default; //! use adsense1d4::{AdSense, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -171,10 +171,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -184,25 +184,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/adsense2/src/lib.rs b/gen/adsense2/src/lib.rs index 78e46e3aad..4b1794e0a6 100644 --- a/gen/adsense2/src/lib.rs +++ b/gen/adsense2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/adsense2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Adsense) ... +//! Handle the following *Resources* with ease from the central [hub](Adsense) ... //! //! * [accounts](api::Account) //! * [*adclients adunits create*](api::AccountAdclientAdunitCreateCall), [*adclients adunits get*](api::AccountAdclientAdunitGetCall), [*adclients adunits get adcode*](api::AccountAdclientAdunitGetAdcodeCall), [*adclients adunits list*](api::AccountAdclientAdunitListCall), [*adclients adunits list linked custom channels*](api::AccountAdclientAdunitListLinkedCustomChannelCall), [*adclients adunits patch*](api::AccountAdclientAdunitPatchCall), [*adclients customchannels create*](api::AccountAdclientCustomchannelCreateCall), [*adclients customchannels delete*](api::AccountAdclientCustomchannelDeleteCall), [*adclients customchannels get*](api::AccountAdclientCustomchannelGetCall), [*adclients customchannels list*](api::AccountAdclientCustomchannelListCall), [*adclients customchannels list linked ad units*](api::AccountAdclientCustomchannelListLinkedAdUnitCall), [*adclients customchannels patch*](api::AccountAdclientCustomchannelPatchCall), [*adclients get*](api::AccountAdclientGetCall), [*adclients get adcode*](api::AccountAdclientGetAdcodeCall), [*adclients list*](api::AccountAdclientListCall), [*adclients urlchannels get*](api::AccountAdclientUrlchannelGetCall), [*adclients urlchannels list*](api::AccountAdclientUrlchannelListCall), [*alerts list*](api::AccountAlertListCall), [*get*](api::AccountGetCall), [*get ad blocking recovery tag*](api::AccountGetAdBlockingRecoveryTagCall), [*list*](api::AccountListCall), [*list child accounts*](api::AccountListChildAccountCall), [*payments list*](api::AccountPaymentListCall), [*reports generate*](api::AccountReportGenerateCall), [*reports generate csv*](api::AccountReportGenerateCsvCall), [*reports get saved*](api::AccountReportGetSavedCall), [*reports saved generate*](api::AccountReportSavedGenerateCall), [*reports saved generate csv*](api::AccountReportSavedGenerateCsvCall), [*reports saved list*](api::AccountReportSavedListCall), [*sites get*](api::AccountSiteGetCall) and [*sites list*](api::AccountSiteListCall) @@ -80,8 +80,8 @@ //! let r = hub.accounts().list_child_accounts(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -109,12 +109,12 @@ //! use std::default::Default; //! use adsense2::{Adsense, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -165,10 +165,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -178,25 +178,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/adsensehost4d1/src/lib.rs b/gen/adsensehost4d1/src/lib.rs index adb5ae0029..88284cc228 100644 --- a/gen/adsensehost4d1/src/lib.rs +++ b/gen/adsensehost4d1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/adsensehost4d1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AdSenseHost) ... +//! Handle the following *Resources* with ease from the central [hub](AdSenseHost) ... //! //! * [accounts](api::Account) //! * [*adclients get*](api::AccountAdclientGetCall), [*adclients list*](api::AccountAdclientListCall), [*adunits delete*](api::AccountAdunitDeleteCall), [*adunits get*](api::AccountAdunitGetCall), [*adunits get ad code*](api::AccountAdunitGetAdCodeCall), [*adunits insert*](api::AccountAdunitInsertCall), [*adunits list*](api::AccountAdunitListCall), [*adunits patch*](api::AccountAdunitPatchCall), [*adunits update*](api::AccountAdunitUpdateCall), [*get*](api::AccountGetCall), [*list*](api::AccountListCall) and [*reports generate*](api::AccountReportGenerateCall) @@ -71,8 +71,8 @@ //! let r = hub.accounts().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -100,12 +100,12 @@ //! use std::default::Default; //! use adsensehost4d1::{AdSenseHost, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -148,10 +148,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -161,25 +161,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/alertcenter1_beta1/src/lib.rs b/gen/alertcenter1_beta1/src/lib.rs index 1d613bbf1c..7b28b87f5a 100644 --- a/gen/alertcenter1_beta1/src/lib.rs +++ b/gen/alertcenter1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/alertcenter1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AlertCenter) ... +//! Handle the following *Resources* with ease from the central [hub](AlertCenter) ... //! //! * [alerts](api::Alert) //! * [*batch delete*](api::AlertBatchDeleteCall), [*batch undelete*](api::AlertBatchUndeleteCall), [*delete*](api::AlertDeleteCall), [*feedback create*](api::AlertFeedbackCreateCall), [*feedback list*](api::AlertFeedbackListCall), [*get*](api::AlertGetCall), [*get metadata*](api::AlertGetMetadataCall), [*list*](api::AlertListCall) and [*undelete*](api::AlertUndeleteCall) @@ -62,8 +62,8 @@ //! let r = hub.alerts().undelete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use alertcenter1_beta1::{AlertCenter, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -137,10 +137,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -150,25 +150,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/analytics3/src/lib.rs b/gen/analytics3/src/lib.rs index bb982e5357..2666eab479 100644 --- a/gen/analytics3/src/lib.rs +++ b/gen/analytics3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/analytics3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Analytics) ... +//! Handle the following *Resources* with ease from the central [hub](Analytics) ... //! //! * data //! * [*ga get*](api::DataGaGetCall), [*mcf get*](api::DataMcfGetCall) and [*realtime get*](api::DataRealtimeGetCall) @@ -67,8 +67,8 @@ //! let r = hub.management().webproperty_user_links_update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -97,12 +97,12 @@ //! use std::default::Default; //! use analytics3::{Analytics, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -143,10 +143,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -156,25 +156,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/analyticsadmin1_alpha/src/lib.rs b/gen/analyticsadmin1_alpha/src/lib.rs index f600c8ee8f..4ba3db1cac 100644 --- a/gen/analyticsadmin1_alpha/src/lib.rs +++ b/gen/analyticsadmin1_alpha/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/analyticsadmin1_alpha). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](GoogleAnalyticsAdmin) ... +//! Handle the following *Resources* with ease from the central [hub](GoogleAnalyticsAdmin) ... //! //! * account summaries //! * [*list*](api::AccountSummaryListCall) @@ -78,8 +78,8 @@ //! let r = hub.properties().delete_connected_site_tag(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -108,12 +108,12 @@ //! use std::default::Default; //! use analyticsadmin1_alpha::{GoogleAnalyticsAdmin, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -154,10 +154,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -167,25 +167,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/analyticsdata1_beta/src/lib.rs b/gen/analyticsdata1_beta/src/lib.rs index 227db7756b..91e501f6ed 100644 --- a/gen/analyticsdata1_beta/src/lib.rs +++ b/gen/analyticsdata1_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/analyticsdata1_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AnalyticsData) ... +//! Handle the following *Resources* with ease from the central [hub](AnalyticsData) ... //! //! * properties //! * [*audience exports create*](api::PropertyAudienceExportCreateCall), [*audience exports get*](api::PropertyAudienceExportGetCall), [*audience exports list*](api::PropertyAudienceExportListCall), [*audience exports query*](api::PropertyAudienceExportQueryCall), [*batch run pivot reports*](api::PropertyBatchRunPivotReportCall), [*batch run reports*](api::PropertyBatchRunReportCall), [*check compatibility*](api::PropertyCheckCompatibilityCall), [*get metadata*](api::PropertyGetMetadataCall), [*run pivot report*](api::PropertyRunPivotReportCall), [*run realtime report*](api::PropertyRunRealtimeReportCall) and [*run report*](api::PropertyRunReportCall) @@ -51,8 +51,8 @@ //! let r = hub.properties().audience_exports_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use analyticsdata1_beta::{AnalyticsData, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/analyticsreporting4/src/lib.rs b/gen/analyticsreporting4/src/lib.rs index b6225729b7..0442df2859 100644 --- a/gen/analyticsreporting4/src/lib.rs +++ b/gen/analyticsreporting4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/analyticsreporting4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AnalyticsReporting) ... +//! Handle the following *Resources* with ease from the central [hub](AnalyticsReporting) ... //! //! * [reports](api::Report) //! * [*batch get*](api::ReportBatchGetCall) @@ -52,8 +52,8 @@ //! let r = hub.user_activity().search(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use analyticsreporting4::{AnalyticsReporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/androiddeviceprovisioning1/src/api.rs b/gen/androiddeviceprovisioning1/src/api.rs index bf1da12a70..fa2364fd60 100644 --- a/gen/androiddeviceprovisioning1/src/api.rs +++ b/gen/androiddeviceprovisioning1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use androiddeviceprovisioning1::{AndroidProvisioningPartner, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/androiddeviceprovisioning1/src/lib.rs b/gen/androiddeviceprovisioning1/src/lib.rs index 1e1ada5be3..228262076c 100644 --- a/gen/androiddeviceprovisioning1/src/lib.rs +++ b/gen/androiddeviceprovisioning1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/androiddeviceprovisioning1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AndroidProvisioningPartner) ... +//! Handle the following *Resources* with ease from the central [hub](AndroidProvisioningPartner) ... //! //! * customers //! * [*configurations create*](api::CustomerConfigurationCreateCall), [*configurations delete*](api::CustomerConfigurationDeleteCall), [*configurations get*](api::CustomerConfigurationGetCall), [*configurations list*](api::CustomerConfigurationListCall), [*configurations patch*](api::CustomerConfigurationPatchCall), [*devices apply configuration*](api::CustomerDeviceApplyConfigurationCall), [*devices get*](api::CustomerDeviceGetCall), [*devices list*](api::CustomerDeviceListCall), [*devices remove configuration*](api::CustomerDeviceRemoveConfigurationCall), [*devices unclaim*](api::CustomerDeviceUnclaimCall), [*dpcs list*](api::CustomerDpcListCall) and [*list*](api::CustomerListCall) @@ -58,8 +58,8 @@ //! let r = hub.partners().devices_unclaim(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use androiddeviceprovisioning1::{AndroidProvisioningPartner, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/androidenterprise1/src/lib.rs b/gen/androidenterprise1/src/lib.rs index 11115b3d77..8a49cb24a3 100644 --- a/gen/androidenterprise1/src/lib.rs +++ b/gen/androidenterprise1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/androidenterprise1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AndroidEnterprise) ... +//! Handle the following *Resources* with ease from the central [hub](AndroidEnterprise) ... //! //! * [devices](api::Device) //! * [*force report upload*](api::DeviceForceReportUploadCall), [*get*](api::DeviceGetCall), [*get state*](api::DeviceGetStateCall), [*list*](api::DeviceListCall), [*set state*](api::DeviceSetStateCall) and [*update*](api::DeviceUpdateCall) @@ -94,8 +94,8 @@ //! let r = hub.enterprises().unenroll(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -123,12 +123,12 @@ //! use std::default::Default; //! use androidenterprise1::{AndroidEnterprise, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -166,10 +166,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -179,25 +179,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/androidmanagement1/src/lib.rs b/gen/androidmanagement1/src/lib.rs index 764d4a15e6..a8d02e1ada 100644 --- a/gen/androidmanagement1/src/lib.rs +++ b/gen/androidmanagement1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/androidmanagement1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AndroidManagement) ... +//! Handle the following *Resources* with ease from the central [hub](AndroidManagement) ... //! //! * [enterprises](api::Enterprise) //! * [*applications get*](api::EnterpriseApplicationGetCall), [*create*](api::EnterpriseCreateCall), [*delete*](api::EnterpriseDeleteCall), [*devices delete*](api::EnterpriseDeviceDeleteCall), [*devices get*](api::EnterpriseDeviceGetCall), [*devices issue command*](api::EnterpriseDeviceIssueCommandCall), [*devices list*](api::EnterpriseDeviceListCall), [*devices operations cancel*](api::EnterpriseDeviceOperationCancelCall), [*devices operations get*](api::EnterpriseDeviceOperationGetCall), [*devices operations list*](api::EnterpriseDeviceOperationListCall), [*devices patch*](api::EnterpriseDevicePatchCall), [*enrollment tokens create*](api::EnterpriseEnrollmentTokenCreateCall), [*enrollment tokens delete*](api::EnterpriseEnrollmentTokenDeleteCall), [*enrollment tokens get*](api::EnterpriseEnrollmentTokenGetCall), [*enrollment tokens list*](api::EnterpriseEnrollmentTokenListCall), [*get*](api::EnterpriseGetCall), [*list*](api::EnterpriseListCall), [*migration tokens create*](api::EnterpriseMigrationTokenCreateCall), [*migration tokens get*](api::EnterpriseMigrationTokenGetCall), [*migration tokens list*](api::EnterpriseMigrationTokenListCall), [*patch*](api::EnterprisePatchCall), [*policies delete*](api::EnterprisePolicyDeleteCall), [*policies get*](api::EnterprisePolicyGetCall), [*policies list*](api::EnterprisePolicyListCall), [*policies patch*](api::EnterprisePolicyPatchCall), [*web apps create*](api::EnterpriseWebAppCreateCall), [*web apps delete*](api::EnterpriseWebAppDeleteCall), [*web apps get*](api::EnterpriseWebAppGetCall), [*web apps list*](api::EnterpriseWebAppListCall), [*web apps patch*](api::EnterpriseWebAppPatchCall) and [*web tokens create*](api::EnterpriseWebTokenCreateCall) @@ -84,8 +84,8 @@ //! let r = hub.enterprises().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -114,12 +114,12 @@ //! use std::default::Default; //! use androidmanagement1::{AndroidManagement, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -164,10 +164,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -177,25 +177,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/androidpublisher2/src/lib.rs b/gen/androidpublisher2/src/lib.rs index ae3b3f4322..69684036d2 100644 --- a/gen/androidpublisher2/src/lib.rs +++ b/gen/androidpublisher2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/androidpublisher2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AndroidPublisher) ... +//! Handle the following *Resources* with ease from the central [hub](AndroidPublisher) ... //! //! * edits //! * [*apklistings delete*](api::EditApklistingDeleteCall), [*apklistings deleteall*](api::EditApklistingDeleteallCall), [*apklistings get*](api::EditApklistingGetCall), [*apklistings list*](api::EditApklistingListCall), [*apklistings patch*](api::EditApklistingPatchCall), [*apklistings update*](api::EditApklistingUpdateCall), [*apks addexternallyhosted*](api::EditApkAddexternallyhostedCall), [*apks list*](api::EditApkListCall), [*apks upload*](api::EditApkUploadCall), [*bundles list*](api::EditBundleListCall), [*bundles upload*](api::EditBundleUploadCall), [*commit*](api::EditCommitCall), [*delete*](api::EditDeleteCall), [*deobfuscationfiles upload*](api::EditDeobfuscationfileUploadCall), [*details get*](api::EditDetailGetCall), [*details patch*](api::EditDetailPatchCall), [*details update*](api::EditDetailUpdateCall), [*expansionfiles get*](api::EditExpansionfileGetCall), [*expansionfiles patch*](api::EditExpansionfilePatchCall), [*expansionfiles update*](api::EditExpansionfileUpdateCall), [*expansionfiles upload*](api::EditExpansionfileUploadCall), [*get*](api::EditGetCall), [*images delete*](api::EditImageDeleteCall), [*images deleteall*](api::EditImageDeleteallCall), [*images list*](api::EditImageListCall), [*images upload*](api::EditImageUploadCall), [*insert*](api::EditInsertCall), [*listings delete*](api::EditListingDeleteCall), [*listings deleteall*](api::EditListingDeleteallCall), [*listings get*](api::EditListingGetCall), [*listings list*](api::EditListingListCall), [*listings patch*](api::EditListingPatchCall), [*listings update*](api::EditListingUpdateCall), [*testers get*](api::EditTesterGetCall), [*testers patch*](api::EditTesterPatchCall), [*testers update*](api::EditTesterUpdateCall), [*tracks get*](api::EditTrackGetCall), [*tracks list*](api::EditTrackListCall), [*tracks patch*](api::EditTrackPatchCall), [*tracks update*](api::EditTrackUpdateCall) and [*validate*](api::EditValidateCall) @@ -69,8 +69,8 @@ //! let r = hub.inappproducts().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -99,12 +99,12 @@ //! use std::default::Default; //! use androidpublisher2::{AndroidPublisher, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -146,10 +146,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -159,25 +159,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/androidpublisher3/src/lib.rs b/gen/androidpublisher3/src/lib.rs index 774939e3cd..28bc2377e1 100644 --- a/gen/androidpublisher3/src/lib.rs +++ b/gen/androidpublisher3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/androidpublisher3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AndroidPublisher) ... +//! Handle the following *Resources* with ease from the central [hub](AndroidPublisher) ... //! //! * applications //! * [*data safety*](api::ApplicationDataSafetyCall), [*device tier configs create*](api::ApplicationDeviceTierConfigCreateCall), [*device tier configs get*](api::ApplicationDeviceTierConfigGetCall) and [*device tier configs list*](api::ApplicationDeviceTierConfigListCall) @@ -96,8 +96,8 @@ //! let r = hub.monetization().subscriptions_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -126,12 +126,12 @@ //! use std::default::Default; //! use androidpublisher3::{AndroidPublisher, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -176,10 +176,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -189,25 +189,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/apigateway1/src/lib.rs b/gen/apigateway1/src/lib.rs index a76d47456e..ba8ae88489 100644 --- a/gen/apigateway1/src/lib.rs +++ b/gen/apigateway1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/apigateway1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Apigateway) ... +//! Handle the following *Resources* with ease from the central [hub](Apigateway) ... //! //! * projects //! * [*locations apis configs create*](api::ProjectLocationApiConfigCreateCall), [*locations apis configs delete*](api::ProjectLocationApiConfigDeleteCall), [*locations apis configs get*](api::ProjectLocationApiConfigGetCall), [*locations apis configs get iam policy*](api::ProjectLocationApiConfigGetIamPolicyCall), [*locations apis configs list*](api::ProjectLocationApiConfigListCall), [*locations apis configs patch*](api::ProjectLocationApiConfigPatchCall), [*locations apis configs set iam policy*](api::ProjectLocationApiConfigSetIamPolicyCall), [*locations apis configs test iam permissions*](api::ProjectLocationApiConfigTestIamPermissionCall), [*locations apis create*](api::ProjectLocationApiCreateCall), [*locations apis delete*](api::ProjectLocationApiDeleteCall), [*locations apis get*](api::ProjectLocationApiGetCall), [*locations apis get iam policy*](api::ProjectLocationApiGetIamPolicyCall), [*locations apis list*](api::ProjectLocationApiListCall), [*locations apis patch*](api::ProjectLocationApiPatchCall), [*locations apis set iam policy*](api::ProjectLocationApiSetIamPolicyCall), [*locations apis test iam permissions*](api::ProjectLocationApiTestIamPermissionCall), [*locations gateways create*](api::ProjectLocationGatewayCreateCall), [*locations gateways delete*](api::ProjectLocationGatewayDeleteCall), [*locations gateways get*](api::ProjectLocationGatewayGetCall), [*locations gateways get iam policy*](api::ProjectLocationGatewayGetIamPolicyCall), [*locations gateways list*](api::ProjectLocationGatewayListCall), [*locations gateways patch*](api::ProjectLocationGatewayPatchCall), [*locations gateways set iam policy*](api::ProjectLocationGatewaySetIamPolicyCall), [*locations gateways test iam permissions*](api::ProjectLocationGatewayTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use apigateway1::{Apigateway, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/apigee1/src/lib.rs b/gen/apigee1/src/lib.rs index 44ab587c51..7f77248f93 100644 --- a/gen/apigee1/src/lib.rs +++ b/gen/apigee1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/apigee1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Apigee) ... +//! Handle the following *Resources* with ease from the central [hub](Apigee) ... //! //! * hybrid //! * [*issuers list*](api::HybridIssuerListCall) @@ -79,8 +79,8 @@ //! let r = hub.projects().provision_organization(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -109,12 +109,12 @@ //! use std::default::Default; //! use apigee1::{Apigee, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -156,10 +156,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -169,25 +169,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/apikeys2/src/lib.rs b/gen/apikeys2/src/lib.rs index a9ea8b642b..339afe2901 100644 --- a/gen/apikeys2/src/lib.rs +++ b/gen/apikeys2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/apikeys2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ApiKeysService) ... +//! Handle the following *Resources* with ease from the central [hub](ApiKeysService) ... //! //! * keys //! * [*lookup key*](api::KeyLookupKeyCall) @@ -58,8 +58,8 @@ //! let r = hub.projects().locations_keys_undelete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use apikeys2::{ApiKeysService, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/appengine1/src/lib.rs b/gen/appengine1/src/lib.rs index 3089b6f9e0..4f0a2b40b7 100644 --- a/gen/appengine1/src/lib.rs +++ b/gen/appengine1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/appengine1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Appengine) ... +//! Handle the following *Resources* with ease from the central [hub](Appengine) ... //! //! * apps //! * [*authorized certificates create*](api::AppAuthorizedCertificateCreateCall), [*authorized certificates delete*](api::AppAuthorizedCertificateDeleteCall), [*authorized certificates get*](api::AppAuthorizedCertificateGetCall), [*authorized certificates list*](api::AppAuthorizedCertificateListCall), [*authorized certificates patch*](api::AppAuthorizedCertificatePatchCall), [*authorized domains list*](api::AppAuthorizedDomainListCall), [*create*](api::AppCreateCall), [*domain mappings create*](api::AppDomainMappingCreateCall), [*domain mappings delete*](api::AppDomainMappingDeleteCall), [*domain mappings get*](api::AppDomainMappingGetCall), [*domain mappings list*](api::AppDomainMappingListCall), [*domain mappings patch*](api::AppDomainMappingPatchCall), [*firewall ingress rules batch update*](api::AppFirewallIngressRuleBatchUpdateCall), [*firewall ingress rules create*](api::AppFirewallIngressRuleCreateCall), [*firewall ingress rules delete*](api::AppFirewallIngressRuleDeleteCall), [*firewall ingress rules get*](api::AppFirewallIngressRuleGetCall), [*firewall ingress rules list*](api::AppFirewallIngressRuleListCall), [*firewall ingress rules patch*](api::AppFirewallIngressRulePatchCall), [*get*](api::AppGetCall), [*list runtimes*](api::AppListRuntimeCall), [*locations get*](api::AppLocationGetCall), [*locations list*](api::AppLocationListCall), [*operations get*](api::AppOperationGetCall), [*operations list*](api::AppOperationListCall), [*patch*](api::AppPatchCall), [*repair*](api::AppRepairCall), [*services delete*](api::AppServiceDeleteCall), [*services get*](api::AppServiceGetCall), [*services list*](api::AppServiceListCall), [*services patch*](api::AppServicePatchCall), [*services versions create*](api::AppServiceVersionCreateCall), [*services versions delete*](api::AppServiceVersionDeleteCall), [*services versions get*](api::AppServiceVersionGetCall), [*services versions instances debug*](api::AppServiceVersionInstanceDebugCall), [*services versions instances delete*](api::AppServiceVersionInstanceDeleteCall), [*services versions instances get*](api::AppServiceVersionInstanceGetCall), [*services versions instances list*](api::AppServiceVersionInstanceListCall), [*services versions list*](api::AppServiceVersionListCall) and [*services versions patch*](api::AppServiceVersionPatchCall) @@ -65,8 +65,8 @@ //! let r = hub.apps().repair(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -95,12 +95,12 @@ //! use std::default::Default; //! use appengine1::{Appengine, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/appengine1_beta4/src/lib.rs b/gen/appengine1_beta4/src/lib.rs index 1fad6ee332..b3ceaf3429 100644 --- a/gen/appengine1_beta4/src/lib.rs +++ b/gen/appengine1_beta4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/appengine1_beta4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Appengine) ... +//! Handle the following *Resources* with ease from the central [hub](Appengine) ... //! //! * apps //! * [*create*](api::AppCreateCall), [*get*](api::AppGetCall), [*locations get*](api::AppLocationGetCall), [*locations list*](api::AppLocationListCall), [*modules delete*](api::AppModuleDeleteCall), [*modules get*](api::AppModuleGetCall), [*modules list*](api::AppModuleListCall), [*modules patch*](api::AppModulePatchCall), [*modules versions create*](api::AppModuleVersionCreateCall), [*modules versions delete*](api::AppModuleVersionDeleteCall), [*modules versions get*](api::AppModuleVersionGetCall), [*modules versions instances debug*](api::AppModuleVersionInstanceDebugCall), [*modules versions instances delete*](api::AppModuleVersionInstanceDeleteCall), [*modules versions instances get*](api::AppModuleVersionInstanceGetCall), [*modules versions instances list*](api::AppModuleVersionInstanceListCall), [*modules versions list*](api::AppModuleVersionListCall), [*modules versions patch*](api::AppModuleVersionPatchCall), [*operations get*](api::AppOperationGetCall), [*operations list*](api::AppOperationListCall) and [*patch*](api::AppPatchCall) @@ -59,8 +59,8 @@ //! let r = hub.apps().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use appengine1_beta4::{Appengine, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/appengine1_beta5/src/lib.rs b/gen/appengine1_beta5/src/lib.rs index 96324e258e..41a4121e2a 100644 --- a/gen/appengine1_beta5/src/lib.rs +++ b/gen/appengine1_beta5/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/appengine1_beta5). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Appengine) ... +//! Handle the following *Resources* with ease from the central [hub](Appengine) ... //! //! * apps //! * [*create*](api::AppCreateCall), [*get*](api::AppGetCall), [*locations get*](api::AppLocationGetCall), [*locations list*](api::AppLocationListCall), [*operations get*](api::AppOperationGetCall), [*operations list*](api::AppOperationListCall), [*patch*](api::AppPatchCall), [*services delete*](api::AppServiceDeleteCall), [*services get*](api::AppServiceGetCall), [*services list*](api::AppServiceListCall), [*services patch*](api::AppServicePatchCall), [*services versions create*](api::AppServiceVersionCreateCall), [*services versions delete*](api::AppServiceVersionDeleteCall), [*services versions get*](api::AppServiceVersionGetCall), [*services versions instances debug*](api::AppServiceVersionInstanceDebugCall), [*services versions instances delete*](api::AppServiceVersionInstanceDeleteCall), [*services versions instances get*](api::AppServiceVersionInstanceGetCall), [*services versions instances list*](api::AppServiceVersionInstanceListCall), [*services versions list*](api::AppServiceVersionListCall) and [*services versions patch*](api::AppServiceVersionPatchCall) @@ -59,8 +59,8 @@ //! let r = hub.apps().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use appengine1_beta5::{Appengine, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/appsactivity1/src/lib.rs b/gen/appsactivity1/src/lib.rs index a85970998e..a569cafbf7 100644 --- a/gen/appsactivity1/src/lib.rs +++ b/gen/appsactivity1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/appsactivity1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Appsactivity) ... +//! Handle the following *Resources* with ease from the central [hub](Appsactivity) ... //! //! * [activities](api::Activity) //! * [*list*](api::ActivityListCall) @@ -50,8 +50,8 @@ //! let r = hub.activities().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use appsactivity1::{Appsactivity, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/appstate1/src/lib.rs b/gen/appstate1/src/lib.rs index 185feeac02..2e0d2839d4 100644 --- a/gen/appstate1/src/lib.rs +++ b/gen/appstate1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/appstate1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AppState) ... +//! Handle the following *Resources* with ease from the central [hub](AppState) ... //! //! * states //! * [*clear*](api::StateClearCall), [*delete*](api::StateDeleteCall), [*get*](api::StateGetCall), [*list*](api::StateListCall) and [*update*](api::StateUpdateCall) @@ -51,8 +51,8 @@ //! let r = hub.states().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use appstate1::{AppState, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/area120tables1_alpha1/src/lib.rs b/gen/area120tables1_alpha1/src/lib.rs index c6e148c7f8..628b6c656a 100644 --- a/gen/area120tables1_alpha1/src/lib.rs +++ b/gen/area120tables1_alpha1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/area120tables1_alpha1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Area120Tables) ... +//! Handle the following *Resources* with ease from the central [hub](Area120Tables) ... //! //! * [tables](api::Table) //! * [*get*](api::TableGetCall), [*list*](api::TableListCall), [*rows batch create*](api::TableRowBatchCreateCall), [*rows batch delete*](api::TableRowBatchDeleteCall), [*rows batch update*](api::TableRowBatchUpdateCall), [*rows create*](api::TableRowCreateCall), [*rows delete*](api::TableRowDeleteCall), [*rows get*](api::TableRowGetCall), [*rows list*](api::TableRowListCall) and [*rows patch*](api::TableRowPatchCall) @@ -61,8 +61,8 @@ //! let r = hub.tables().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use area120tables1_alpha1::{Area120Tables, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/artifactregistry1/src/lib.rs b/gen/artifactregistry1/src/lib.rs index eeb089ac84..dbde74d9b9 100644 --- a/gen/artifactregistry1/src/lib.rs +++ b/gen/artifactregistry1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/artifactregistry1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ArtifactRegistry) ... +//! Handle the following *Resources* with ease from the central [hub](ArtifactRegistry) ... //! //! * projects //! * [*get project settings*](api::ProjectGetProjectSettingCall), [*locations get*](api::ProjectLocationGetCall), [*locations get vpcsc config*](api::ProjectLocationGetVpcscConfigCall), [*locations list*](api::ProjectLocationListCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations repositories apt artifacts import*](api::ProjectLocationRepositoryAptArtifactImportCall), [*locations repositories apt artifacts upload*](api::ProjectLocationRepositoryAptArtifactUploadCall), [*locations repositories create*](api::ProjectLocationRepositoryCreateCall), [*locations repositories delete*](api::ProjectLocationRepositoryDeleteCall), [*locations repositories docker images get*](api::ProjectLocationRepositoryDockerImageGetCall), [*locations repositories docker images list*](api::ProjectLocationRepositoryDockerImageListCall), [*locations repositories files get*](api::ProjectLocationRepositoryFileGetCall), [*locations repositories files list*](api::ProjectLocationRepositoryFileListCall), [*locations repositories get*](api::ProjectLocationRepositoryGetCall), [*locations repositories get iam policy*](api::ProjectLocationRepositoryGetIamPolicyCall), [*locations repositories go modules upload*](api::ProjectLocationRepositoryGoModuleUploadCall), [*locations repositories googet artifacts import*](api::ProjectLocationRepositoryGoogetArtifactImportCall), [*locations repositories googet artifacts upload*](api::ProjectLocationRepositoryGoogetArtifactUploadCall), [*locations repositories kfp artifacts upload*](api::ProjectLocationRepositoryKfpArtifactUploadCall), [*locations repositories list*](api::ProjectLocationRepositoryListCall), [*locations repositories maven artifacts get*](api::ProjectLocationRepositoryMavenArtifactGetCall), [*locations repositories maven artifacts list*](api::ProjectLocationRepositoryMavenArtifactListCall), [*locations repositories npm packages get*](api::ProjectLocationRepositoryNpmPackageGetCall), [*locations repositories npm packages list*](api::ProjectLocationRepositoryNpmPackageListCall), [*locations repositories packages delete*](api::ProjectLocationRepositoryPackageDeleteCall), [*locations repositories packages get*](api::ProjectLocationRepositoryPackageGetCall), [*locations repositories packages list*](api::ProjectLocationRepositoryPackageListCall), [*locations repositories packages tags create*](api::ProjectLocationRepositoryPackageTagCreateCall), [*locations repositories packages tags delete*](api::ProjectLocationRepositoryPackageTagDeleteCall), [*locations repositories packages tags get*](api::ProjectLocationRepositoryPackageTagGetCall), [*locations repositories packages tags list*](api::ProjectLocationRepositoryPackageTagListCall), [*locations repositories packages tags patch*](api::ProjectLocationRepositoryPackageTagPatchCall), [*locations repositories packages versions batch delete*](api::ProjectLocationRepositoryPackageVersionBatchDeleteCall), [*locations repositories packages versions delete*](api::ProjectLocationRepositoryPackageVersionDeleteCall), [*locations repositories packages versions get*](api::ProjectLocationRepositoryPackageVersionGetCall), [*locations repositories packages versions list*](api::ProjectLocationRepositoryPackageVersionListCall), [*locations repositories patch*](api::ProjectLocationRepositoryPatchCall), [*locations repositories python packages get*](api::ProjectLocationRepositoryPythonPackageGetCall), [*locations repositories python packages list*](api::ProjectLocationRepositoryPythonPackageListCall), [*locations repositories set iam policy*](api::ProjectLocationRepositorySetIamPolicyCall), [*locations repositories test iam permissions*](api::ProjectLocationRepositoryTestIamPermissionCall), [*locations repositories yum artifacts import*](api::ProjectLocationRepositoryYumArtifactImportCall), [*locations repositories yum artifacts upload*](api::ProjectLocationRepositoryYumArtifactUploadCall), [*locations update vpcsc config*](api::ProjectLocationUpdateVpcscConfigCall) and [*update project settings*](api::ProjectUpdateProjectSettingCall) @@ -66,8 +66,8 @@ //! let r = hub.projects().locations_repositories_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use artifactregistry1::{ArtifactRegistry, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -143,10 +143,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -156,25 +156,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/artifactregistry1_beta1/src/lib.rs b/gen/artifactregistry1_beta1/src/lib.rs index 3dff4ec101..14a5bd32f7 100644 --- a/gen/artifactregistry1_beta1/src/lib.rs +++ b/gen/artifactregistry1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/artifactregistry1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ArtifactRegistry) ... +//! Handle the following *Resources* with ease from the central [hub](ArtifactRegistry) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations repositories create*](api::ProjectLocationRepositoryCreateCall), [*locations repositories delete*](api::ProjectLocationRepositoryDeleteCall), [*locations repositories files get*](api::ProjectLocationRepositoryFileGetCall), [*locations repositories files list*](api::ProjectLocationRepositoryFileListCall), [*locations repositories get*](api::ProjectLocationRepositoryGetCall), [*locations repositories get iam policy*](api::ProjectLocationRepositoryGetIamPolicyCall), [*locations repositories list*](api::ProjectLocationRepositoryListCall), [*locations repositories packages delete*](api::ProjectLocationRepositoryPackageDeleteCall), [*locations repositories packages get*](api::ProjectLocationRepositoryPackageGetCall), [*locations repositories packages list*](api::ProjectLocationRepositoryPackageListCall), [*locations repositories packages tags create*](api::ProjectLocationRepositoryPackageTagCreateCall), [*locations repositories packages tags delete*](api::ProjectLocationRepositoryPackageTagDeleteCall), [*locations repositories packages tags get*](api::ProjectLocationRepositoryPackageTagGetCall), [*locations repositories packages tags list*](api::ProjectLocationRepositoryPackageTagListCall), [*locations repositories packages tags patch*](api::ProjectLocationRepositoryPackageTagPatchCall), [*locations repositories packages versions delete*](api::ProjectLocationRepositoryPackageVersionDeleteCall), [*locations repositories packages versions get*](api::ProjectLocationRepositoryPackageVersionGetCall), [*locations repositories packages versions list*](api::ProjectLocationRepositoryPackageVersionListCall), [*locations repositories patch*](api::ProjectLocationRepositoryPatchCall), [*locations repositories set iam policy*](api::ProjectLocationRepositorySetIamPolicyCall) and [*locations repositories test iam permissions*](api::ProjectLocationRepositoryTestIamPermissionCall) @@ -54,8 +54,8 @@ //! let r = hub.projects().locations_repositories_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use artifactregistry1_beta1::{ArtifactRegistry, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/assuredworkloads1/src/lib.rs b/gen/assuredworkloads1/src/lib.rs index 88305ef445..f9e2b664bd 100644 --- a/gen/assuredworkloads1/src/lib.rs +++ b/gen/assuredworkloads1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/assuredworkloads1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Assuredworkloads) ... +//! Handle the following *Resources* with ease from the central [hub](Assuredworkloads) ... //! //! * organizations //! * [*locations operations get*](api::OrganizationLocationOperationGetCall), [*locations operations list*](api::OrganizationLocationOperationListCall), [*locations workloads analyze workload move*](api::OrganizationLocationWorkloadAnalyzeWorkloadMoveCall), [*locations workloads create*](api::OrganizationLocationWorkloadCreateCall), [*locations workloads delete*](api::OrganizationLocationWorkloadDeleteCall), [*locations workloads enable resource monitoring*](api::OrganizationLocationWorkloadEnableResourceMonitoringCall), [*locations workloads get*](api::OrganizationLocationWorkloadGetCall), [*locations workloads list*](api::OrganizationLocationWorkloadListCall), [*locations workloads mutate partner permissions*](api::OrganizationLocationWorkloadMutatePartnerPermissionCall), [*locations workloads patch*](api::OrganizationLocationWorkloadPatchCall), [*locations workloads restrict allowed resources*](api::OrganizationLocationWorkloadRestrictAllowedResourceCall), [*locations workloads violations acknowledge*](api::OrganizationLocationWorkloadViolationAcknowledgeCall), [*locations workloads violations get*](api::OrganizationLocationWorkloadViolationGetCall) and [*locations workloads violations list*](api::OrganizationLocationWorkloadViolationListCall) @@ -53,8 +53,8 @@ //! let r = hub.organizations().locations_workloads_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use assuredworkloads1::{Assuredworkloads, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/authorizedbuyersmarketplace1/src/lib.rs b/gen/authorizedbuyersmarketplace1/src/lib.rs index d40b4a7222..3e18093680 100644 --- a/gen/authorizedbuyersmarketplace1/src/lib.rs +++ b/gen/authorizedbuyersmarketplace1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/authorizedbuyersmarketplace1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AuthorizedBuyersMarketplace) ... +//! Handle the following *Resources* with ease from the central [hub](AuthorizedBuyersMarketplace) ... //! //! * bidders //! * [*finalized deals list*](api::BidderFinalizedDealListCall) @@ -57,8 +57,8 @@ //! let r = hub.buyers().proposals_send_rfp(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use authorizedbuyersmarketplace1::{AuthorizedBuyersMarketplace, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/autoscaler1_beta2/src/lib.rs b/gen/autoscaler1_beta2/src/lib.rs index 2ca51e67b4..3d6bb0b2b0 100644 --- a/gen/autoscaler1_beta2/src/lib.rs +++ b/gen/autoscaler1_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/autoscaler1_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AutoscalerHub) ... +//! Handle the following *Resources* with ease from the central [hub](AutoscalerHub) ... //! //! * [autoscalers](api::Autoscaler) //! * [*delete*](api::AutoscalerDeleteCall), [*get*](api::AutoscalerGetCall), [*insert*](api::AutoscalerInsertCall), [*list*](api::AutoscalerListCall), [*patch*](api::AutoscalerPatchCall) and [*update*](api::AutoscalerUpdateCall) @@ -59,8 +59,8 @@ //! let r = hub.autoscalers().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use autoscaler1_beta2::{AutoscalerHub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/baremetalsolution2/src/lib.rs b/gen/baremetalsolution2/src/lib.rs index c0204d3db8..7c42aeebd6 100644 --- a/gen/baremetalsolution2/src/lib.rs +++ b/gen/baremetalsolution2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/baremetalsolution2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Baremetalsolution) ... +//! Handle the following *Resources* with ease from the central [hub](Baremetalsolution) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations instances detach lun*](api::ProjectLocationInstanceDetachLunCall), [*locations instances disable interactive serial console*](api::ProjectLocationInstanceDisableInteractiveSerialConsoleCall), [*locations instances enable interactive serial console*](api::ProjectLocationInstanceEnableInteractiveSerialConsoleCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances load auth info*](api::ProjectLocationInstanceLoadAuthInfoCall), [*locations instances patch*](api::ProjectLocationInstancePatchCall), [*locations instances rename*](api::ProjectLocationInstanceRenameCall), [*locations instances reset*](api::ProjectLocationInstanceResetCall), [*locations instances start*](api::ProjectLocationInstanceStartCall), [*locations instances stop*](api::ProjectLocationInstanceStopCall), [*locations list*](api::ProjectLocationListCall), [*locations networks get*](api::ProjectLocationNetworkGetCall), [*locations networks list*](api::ProjectLocationNetworkListCall), [*locations networks list network usage*](api::ProjectLocationNetworkListNetworkUsageCall), [*locations networks patch*](api::ProjectLocationNetworkPatchCall), [*locations networks rename*](api::ProjectLocationNetworkRenameCall), [*locations nfs shares create*](api::ProjectLocationNfsShareCreateCall), [*locations nfs shares delete*](api::ProjectLocationNfsShareDeleteCall), [*locations nfs shares get*](api::ProjectLocationNfsShareGetCall), [*locations nfs shares list*](api::ProjectLocationNfsShareListCall), [*locations nfs shares patch*](api::ProjectLocationNfsSharePatchCall), [*locations nfs shares rename*](api::ProjectLocationNfsShareRenameCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations os images get*](api::ProjectLocationOsImageGetCall), [*locations os images list*](api::ProjectLocationOsImageListCall), [*locations provisioning configs create*](api::ProjectLocationProvisioningConfigCreateCall), [*locations provisioning configs get*](api::ProjectLocationProvisioningConfigGetCall), [*locations provisioning configs patch*](api::ProjectLocationProvisioningConfigPatchCall), [*locations provisioning configs submit*](api::ProjectLocationProvisioningConfigSubmitCall), [*locations provisioning quotas list*](api::ProjectLocationProvisioningQuotaListCall), [*locations ssh keys create*](api::ProjectLocationSshKeyCreateCall), [*locations ssh keys delete*](api::ProjectLocationSshKeyDeleteCall), [*locations ssh keys list*](api::ProjectLocationSshKeyListCall), [*locations volumes evict*](api::ProjectLocationVolumeEvictCall), [*locations volumes get*](api::ProjectLocationVolumeGetCall), [*locations volumes list*](api::ProjectLocationVolumeListCall), [*locations volumes luns evict*](api::ProjectLocationVolumeLunEvictCall), [*locations volumes luns get*](api::ProjectLocationVolumeLunGetCall), [*locations volumes luns list*](api::ProjectLocationVolumeLunListCall), [*locations volumes patch*](api::ProjectLocationVolumePatchCall), [*locations volumes rename*](api::ProjectLocationVolumeRenameCall), [*locations volumes resize*](api::ProjectLocationVolumeResizeCall), [*locations volumes snapshots create*](api::ProjectLocationVolumeSnapshotCreateCall), [*locations volumes snapshots delete*](api::ProjectLocationVolumeSnapshotDeleteCall), [*locations volumes snapshots get*](api::ProjectLocationVolumeSnapshotGetCall), [*locations volumes snapshots list*](api::ProjectLocationVolumeSnapshotListCall) and [*locations volumes snapshots restore volume snapshot*](api::ProjectLocationVolumeSnapshotRestoreVolumeSnapshotCall) @@ -66,8 +66,8 @@ //! let r = hub.projects().locations_volumes_resize(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use baremetalsolution2::{Baremetalsolution, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -143,10 +143,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -156,25 +156,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/bigquery2/src/lib.rs b/gen/bigquery2/src/lib.rs index 66a78e4f73..e1983fef08 100644 --- a/gen/bigquery2/src/lib.rs +++ b/gen/bigquery2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/bigquery2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Bigquery) ... +//! Handle the following *Resources* with ease from the central [hub](Bigquery) ... //! //! * [datasets](api::Dataset) //! * [*delete*](api::DatasetDeleteCall), [*get*](api::DatasetGetCall), [*insert*](api::DatasetInsertCall), [*list*](api::DatasetListCall), [*patch*](api::DatasetPatchCall), [*undelete*](api::DatasetUndeleteCall) and [*update*](api::DatasetUpdateCall) @@ -76,8 +76,8 @@ //! let r = hub.tables().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -105,12 +105,12 @@ //! use std::default::Default; //! use bigquery2::{Bigquery, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -148,10 +148,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -161,25 +161,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/bigqueryconnection1_beta1/src/lib.rs b/gen/bigqueryconnection1_beta1/src/lib.rs index e468c0135f..d4217c2a4d 100644 --- a/gen/bigqueryconnection1_beta1/src/lib.rs +++ b/gen/bigqueryconnection1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/bigqueryconnection1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](BigQueryConnectionService) ... +//! Handle the following *Resources* with ease from the central [hub](BigQueryConnectionService) ... //! //! * projects //! * [*locations connections create*](api::ProjectLocationConnectionCreateCall), [*locations connections delete*](api::ProjectLocationConnectionDeleteCall), [*locations connections get*](api::ProjectLocationConnectionGetCall), [*locations connections get iam policy*](api::ProjectLocationConnectionGetIamPolicyCall), [*locations connections list*](api::ProjectLocationConnectionListCall), [*locations connections patch*](api::ProjectLocationConnectionPatchCall), [*locations connections set iam policy*](api::ProjectLocationConnectionSetIamPolicyCall), [*locations connections test iam permissions*](api::ProjectLocationConnectionTestIamPermissionCall) and [*locations connections update credential*](api::ProjectLocationConnectionUpdateCredentialCall) @@ -52,8 +52,8 @@ //! let r = hub.projects().locations_connections_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use bigqueryconnection1_beta1::{BigQueryConnectionService, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/bigquerydatatransfer1/src/lib.rs b/gen/bigquerydatatransfer1/src/lib.rs index 5ed5871c5a..7df9b0800d 100644 --- a/gen/bigquerydatatransfer1/src/lib.rs +++ b/gen/bigquerydatatransfer1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/bigquerydatatransfer1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](BigQueryDataTransfer) ... +//! Handle the following *Resources* with ease from the central [hub](BigQueryDataTransfer) ... //! //! * projects //! * [*data sources check valid creds*](api::ProjectDataSourceCheckValidCredCall), [*data sources get*](api::ProjectDataSourceGetCall), [*data sources list*](api::ProjectDataSourceListCall), [*enroll data sources*](api::ProjectEnrollDataSourceCall), [*locations data sources check valid creds*](api::ProjectLocationDataSourceCheckValidCredCall), [*locations data sources get*](api::ProjectLocationDataSourceGetCall), [*locations data sources list*](api::ProjectLocationDataSourceListCall), [*locations enroll data sources*](api::ProjectLocationEnrollDataSourceCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations transfer configs create*](api::ProjectLocationTransferConfigCreateCall), [*locations transfer configs delete*](api::ProjectLocationTransferConfigDeleteCall), [*locations transfer configs get*](api::ProjectLocationTransferConfigGetCall), [*locations transfer configs list*](api::ProjectLocationTransferConfigListCall), [*locations transfer configs patch*](api::ProjectLocationTransferConfigPatchCall), [*locations transfer configs runs delete*](api::ProjectLocationTransferConfigRunDeleteCall), [*locations transfer configs runs get*](api::ProjectLocationTransferConfigRunGetCall), [*locations transfer configs runs list*](api::ProjectLocationTransferConfigRunListCall), [*locations transfer configs runs transfer logs list*](api::ProjectLocationTransferConfigRunTransferLogListCall), [*locations transfer configs schedule runs*](api::ProjectLocationTransferConfigScheduleRunCall), [*locations transfer configs start manual runs*](api::ProjectLocationTransferConfigStartManualRunCall), [*locations unenroll data sources*](api::ProjectLocationUnenrollDataSourceCall), [*transfer configs create*](api::ProjectTransferConfigCreateCall), [*transfer configs delete*](api::ProjectTransferConfigDeleteCall), [*transfer configs get*](api::ProjectTransferConfigGetCall), [*transfer configs list*](api::ProjectTransferConfigListCall), [*transfer configs patch*](api::ProjectTransferConfigPatchCall), [*transfer configs runs delete*](api::ProjectTransferConfigRunDeleteCall), [*transfer configs runs get*](api::ProjectTransferConfigRunGetCall), [*transfer configs runs list*](api::ProjectTransferConfigRunListCall), [*transfer configs runs transfer logs list*](api::ProjectTransferConfigRunTransferLogListCall), [*transfer configs schedule runs*](api::ProjectTransferConfigScheduleRunCall) and [*transfer configs start manual runs*](api::ProjectTransferConfigStartManualRunCall) @@ -56,8 +56,8 @@ //! let r = hub.projects().enroll_data_sources(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use bigquerydatatransfer1::{BigQueryDataTransfer, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/bigqueryreservation1/src/lib.rs b/gen/bigqueryreservation1/src/lib.rs index 105a72d333..8d8655e5ed 100644 --- a/gen/bigqueryreservation1/src/lib.rs +++ b/gen/bigqueryreservation1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/bigqueryreservation1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](BigQueryReservation) ... +//! Handle the following *Resources* with ease from the central [hub](BigQueryReservation) ... //! //! * projects //! * [*locations capacity commitments create*](api::ProjectLocationCapacityCommitmentCreateCall), [*locations capacity commitments delete*](api::ProjectLocationCapacityCommitmentDeleteCall), [*locations capacity commitments get*](api::ProjectLocationCapacityCommitmentGetCall), [*locations capacity commitments list*](api::ProjectLocationCapacityCommitmentListCall), [*locations capacity commitments merge*](api::ProjectLocationCapacityCommitmentMergeCall), [*locations capacity commitments patch*](api::ProjectLocationCapacityCommitmentPatchCall), [*locations capacity commitments split*](api::ProjectLocationCapacityCommitmentSplitCall), [*locations get bi reservation*](api::ProjectLocationGetBiReservationCall), [*locations reservations assignments create*](api::ProjectLocationReservationAssignmentCreateCall), [*locations reservations assignments delete*](api::ProjectLocationReservationAssignmentDeleteCall), [*locations reservations assignments list*](api::ProjectLocationReservationAssignmentListCall), [*locations reservations assignments move*](api::ProjectLocationReservationAssignmentMoveCall), [*locations reservations assignments patch*](api::ProjectLocationReservationAssignmentPatchCall), [*locations reservations create*](api::ProjectLocationReservationCreateCall), [*locations reservations delete*](api::ProjectLocationReservationDeleteCall), [*locations reservations get*](api::ProjectLocationReservationGetCall), [*locations reservations list*](api::ProjectLocationReservationListCall), [*locations reservations patch*](api::ProjectLocationReservationPatchCall), [*locations search all assignments*](api::ProjectLocationSearchAllAssignmentCall), [*locations search assignments*](api::ProjectLocationSearchAssignmentCall) and [*locations update bi reservation*](api::ProjectLocationUpdateBiReservationCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().locations_capacity_commitments_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use bigqueryreservation1::{BigQueryReservation, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/bigtableadmin2/src/lib.rs b/gen/bigtableadmin2/src/lib.rs index 36486592af..aa0ca822eb 100644 --- a/gen/bigtableadmin2/src/lib.rs +++ b/gen/bigtableadmin2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/bigtableadmin2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](BigtableAdmin) ... +//! Handle the following *Resources* with ease from the central [hub](BigtableAdmin) ... //! //! * [operations](api::Operation) //! * [*get*](api::OperationGetCall) and [*projects operations list*](api::OperationProjectOperationListCall) @@ -64,8 +64,8 @@ //! let r = hub.projects().instances_partial_update_instance(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -93,12 +93,12 @@ //! use std::default::Default; //! use bigtableadmin2::{BigtableAdmin, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -137,10 +137,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -150,25 +150,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/billingbudgets1/src/lib.rs b/gen/billingbudgets1/src/lib.rs index 82fe75ca87..8ade95c048 100644 --- a/gen/billingbudgets1/src/lib.rs +++ b/gen/billingbudgets1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/billingbudgets1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudBillingBudget) ... +//! Handle the following *Resources* with ease from the central [hub](CloudBillingBudget) ... //! //! * billing accounts //! * [*budgets create*](api::BillingAccountBudgetCreateCall), [*budgets delete*](api::BillingAccountBudgetDeleteCall), [*budgets get*](api::BillingAccountBudgetGetCall), [*budgets list*](api::BillingAccountBudgetListCall) and [*budgets patch*](api::BillingAccountBudgetPatchCall) @@ -52,8 +52,8 @@ //! let r = hub.billing_accounts().budgets_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use billingbudgets1::{CloudBillingBudget, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/billingbudgets1_beta1/src/lib.rs b/gen/billingbudgets1_beta1/src/lib.rs index 3ddbfcd776..4193508762 100644 --- a/gen/billingbudgets1_beta1/src/lib.rs +++ b/gen/billingbudgets1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/billingbudgets1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudBillingBudget) ... +//! Handle the following *Resources* with ease from the central [hub](CloudBillingBudget) ... //! //! * billing accounts //! * [*budgets create*](api::BillingAccountBudgetCreateCall), [*budgets delete*](api::BillingAccountBudgetDeleteCall), [*budgets get*](api::BillingAccountBudgetGetCall), [*budgets list*](api::BillingAccountBudgetListCall) and [*budgets patch*](api::BillingAccountBudgetPatchCall) @@ -52,8 +52,8 @@ //! let r = hub.billing_accounts().budgets_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use billingbudgets1_beta1::{CloudBillingBudget, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/binaryauthorization1/src/lib.rs b/gen/binaryauthorization1/src/lib.rs index 2ff104edfd..a518d87ed5 100644 --- a/gen/binaryauthorization1/src/lib.rs +++ b/gen/binaryauthorization1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/binaryauthorization1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](BinaryAuthorization) ... +//! Handle the following *Resources* with ease from the central [hub](BinaryAuthorization) ... //! //! * projects //! * [*attestors create*](api::ProjectAttestorCreateCall), [*attestors delete*](api::ProjectAttestorDeleteCall), [*attestors get*](api::ProjectAttestorGetCall), [*attestors get iam policy*](api::ProjectAttestorGetIamPolicyCall), [*attestors list*](api::ProjectAttestorListCall), [*attestors set iam policy*](api::ProjectAttestorSetIamPolicyCall), [*attestors test iam permissions*](api::ProjectAttestorTestIamPermissionCall), [*attestors update*](api::ProjectAttestorUpdateCall), [*attestors validate attestation occurrence*](api::ProjectAttestorValidateAttestationOccurrenceCall), [*get policy*](api::ProjectGetPolicyCall), [*platforms gke policies evaluate*](api::ProjectPlatformGkePolicyEvaluateCall), [*platforms policies create*](api::ProjectPlatformPolicyCreateCall), [*platforms policies delete*](api::ProjectPlatformPolicyDeleteCall), [*platforms policies get*](api::ProjectPlatformPolicyGetCall), [*platforms policies list*](api::ProjectPlatformPolicyListCall), [*platforms policies replace platform policy*](api::ProjectPlatformPolicyReplacePlatformPolicyCall), [*policy get iam policy*](api::ProjectPolicyGetIamPolicyCall), [*policy set iam policy*](api::ProjectPolicySetIamPolicyCall), [*policy test iam permissions*](api::ProjectPolicyTestIamPermissionCall) and [*update policy*](api::ProjectUpdatePolicyCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().policy_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use binaryauthorization1::{BinaryAuthorization, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/binaryauthorization1_beta1/src/lib.rs b/gen/binaryauthorization1_beta1/src/lib.rs index 8c7e0f16d1..72b2babfc1 100644 --- a/gen/binaryauthorization1_beta1/src/lib.rs +++ b/gen/binaryauthorization1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/binaryauthorization1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](BinaryAuthorization) ... +//! Handle the following *Resources* with ease from the central [hub](BinaryAuthorization) ... //! //! * projects //! * [*attestors create*](api::ProjectAttestorCreateCall), [*attestors delete*](api::ProjectAttestorDeleteCall), [*attestors get*](api::ProjectAttestorGetCall), [*attestors get iam policy*](api::ProjectAttestorGetIamPolicyCall), [*attestors list*](api::ProjectAttestorListCall), [*attestors set iam policy*](api::ProjectAttestorSetIamPolicyCall), [*attestors test iam permissions*](api::ProjectAttestorTestIamPermissionCall), [*attestors update*](api::ProjectAttestorUpdateCall), [*attestors validate attestation occurrence*](api::ProjectAttestorValidateAttestationOccurrenceCall), [*get policy*](api::ProjectGetPolicyCall), [*policy get iam policy*](api::ProjectPolicyGetIamPolicyCall), [*policy set iam policy*](api::ProjectPolicySetIamPolicyCall), [*policy test iam permissions*](api::ProjectPolicyTestIamPermissionCall) and [*update policy*](api::ProjectUpdatePolicyCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().policy_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use binaryauthorization1_beta1::{BinaryAuthorization, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/blogger3/src/lib.rs b/gen/blogger3/src/lib.rs index 24dca96ed7..0fbfc4a9b1 100644 --- a/gen/blogger3/src/lib.rs +++ b/gen/blogger3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/blogger3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Blogger) ... +//! Handle the following *Resources* with ease from the central [hub](Blogger) ... //! //! * [blog user infos](api::BlogUserInfo) //! * [*get*](api::BlogUserInfoGetCall) @@ -73,8 +73,8 @@ //! let r = hub.posts().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -102,12 +102,12 @@ //! use std::default::Default; //! use blogger3::{Blogger, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -154,10 +154,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -167,25 +167,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/books1/src/lib.rs b/gen/books1/src/lib.rs index 4b8c6da611..081b776d6e 100644 --- a/gen/books1/src/lib.rs +++ b/gen/books1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/books1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Books) ... +//! Handle the following *Resources* with ease from the central [hub](Books) ... //! //! * [bookshelves](api::Bookshelf) //! * [*get*](api::BookshelfGetCall), [*list*](api::BookshelfListCall) and [*volumes list*](api::BookshelfVolumeListCall) @@ -84,8 +84,8 @@ //! let r = hub.promooffer().dismiss(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -113,12 +113,12 @@ //! use std::default::Default; //! use books1::{Books, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -162,10 +162,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -175,25 +175,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/calendar3/src/lib.rs b/gen/calendar3/src/lib.rs index 3691a9cfd8..8a1774ac49 100644 --- a/gen/calendar3/src/lib.rs +++ b/gen/calendar3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/calendar3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CalendarHub) ... +//! Handle the following *Resources* with ease from the central [hub](CalendarHub) ... //! //! * [acl](api::Acl) //! * [*delete*](api::AclDeleteCall), [*get*](api::AclGetCall), [*insert*](api::AclInsertCall), [*list*](api::AclListCall), [*patch*](api::AclPatchCall), [*update*](api::AclUpdateCall) and [*watch*](api::AclWatchCall) @@ -86,8 +86,8 @@ //! let r = hub.events().watch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -116,12 +116,12 @@ //! use std::default::Default; //! use calendar3::{CalendarHub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -180,10 +180,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -193,25 +193,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/certificatemanager1/src/lib.rs b/gen/certificatemanager1/src/lib.rs index a2012b26a1..9b7d1a65e5 100644 --- a/gen/certificatemanager1/src/lib.rs +++ b/gen/certificatemanager1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/certificatemanager1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CertificateManager) ... +//! Handle the following *Resources* with ease from the central [hub](CertificateManager) ... //! //! * projects //! * [*locations certificate issuance configs create*](api::ProjectLocationCertificateIssuanceConfigCreateCall), [*locations certificate issuance configs delete*](api::ProjectLocationCertificateIssuanceConfigDeleteCall), [*locations certificate issuance configs get*](api::ProjectLocationCertificateIssuanceConfigGetCall), [*locations certificate issuance configs list*](api::ProjectLocationCertificateIssuanceConfigListCall), [*locations certificate maps certificate map entries create*](api::ProjectLocationCertificateMapCertificateMapEntryCreateCall), [*locations certificate maps certificate map entries delete*](api::ProjectLocationCertificateMapCertificateMapEntryDeleteCall), [*locations certificate maps certificate map entries get*](api::ProjectLocationCertificateMapCertificateMapEntryGetCall), [*locations certificate maps certificate map entries list*](api::ProjectLocationCertificateMapCertificateMapEntryListCall), [*locations certificate maps certificate map entries patch*](api::ProjectLocationCertificateMapCertificateMapEntryPatchCall), [*locations certificate maps create*](api::ProjectLocationCertificateMapCreateCall), [*locations certificate maps delete*](api::ProjectLocationCertificateMapDeleteCall), [*locations certificate maps get*](api::ProjectLocationCertificateMapGetCall), [*locations certificate maps list*](api::ProjectLocationCertificateMapListCall), [*locations certificate maps patch*](api::ProjectLocationCertificateMapPatchCall), [*locations certificates create*](api::ProjectLocationCertificateCreateCall), [*locations certificates delete*](api::ProjectLocationCertificateDeleteCall), [*locations certificates get*](api::ProjectLocationCertificateGetCall), [*locations certificates list*](api::ProjectLocationCertificateListCall), [*locations certificates patch*](api::ProjectLocationCertificatePatchCall), [*locations dns authorizations create*](api::ProjectLocationDnsAuthorizationCreateCall), [*locations dns authorizations delete*](api::ProjectLocationDnsAuthorizationDeleteCall), [*locations dns authorizations get*](api::ProjectLocationDnsAuthorizationGetCall), [*locations dns authorizations list*](api::ProjectLocationDnsAuthorizationListCall), [*locations dns authorizations patch*](api::ProjectLocationDnsAuthorizationPatchCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations trust configs create*](api::ProjectLocationTrustConfigCreateCall), [*locations trust configs delete*](api::ProjectLocationTrustConfigDeleteCall), [*locations trust configs get*](api::ProjectLocationTrustConfigGetCall), [*locations trust configs list*](api::ProjectLocationTrustConfigListCall) and [*locations trust configs patch*](api::ProjectLocationTrustConfigPatchCall) @@ -67,8 +67,8 @@ //! let r = hub.projects().locations_trust_configs_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -97,12 +97,12 @@ //! use std::default::Default; //! use certificatemanager1::{CertificateManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -144,10 +144,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -157,25 +157,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/chromemanagement1/src/lib.rs b/gen/chromemanagement1/src/lib.rs index a0b8812358..7a3aae5972 100644 --- a/gen/chromemanagement1/src/lib.rs +++ b/gen/chromemanagement1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/chromemanagement1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ChromeManagement) ... +//! Handle the following *Resources* with ease from the central [hub](ChromeManagement) ... //! //! * customers //! * [*apps android get*](api::CustomerAppAndroidGetCall), [*apps chrome get*](api::CustomerAppChromeGetCall), [*apps count chrome app requests*](api::CustomerAppCountChromeAppRequestCall), [*apps web get*](api::CustomerAppWebGetCall), [*reports count chrome browsers needing attention*](api::CustomerReportCountChromeBrowsersNeedingAttentionCall), [*reports count chrome devices reaching auto expiration date*](api::CustomerReportCountChromeDevicesReachingAutoExpirationDateCall), [*reports count chrome devices that need attention*](api::CustomerReportCountChromeDevicesThatNeedAttentionCall), [*reports count chrome hardware fleet devices*](api::CustomerReportCountChromeHardwareFleetDeviceCall), [*reports count chrome versions*](api::CustomerReportCountChromeVersionCall), [*reports count installed apps*](api::CustomerReportCountInstalledAppCall), [*reports count print jobs by printer*](api::CustomerReportCountPrintJobsByPrinterCall), [*reports count print jobs by user*](api::CustomerReportCountPrintJobsByUserCall), [*reports enumerate print jobs*](api::CustomerReportEnumeratePrintJobCall), [*reports find installed app devices*](api::CustomerReportFindInstalledAppDeviceCall), [*telemetry devices get*](api::CustomerTelemetryDeviceGetCall), [*telemetry devices list*](api::CustomerTelemetryDeviceListCall), [*telemetry events list*](api::CustomerTelemetryEventListCall), [*telemetry notification configs create*](api::CustomerTelemetryNotificationConfigCreateCall), [*telemetry notification configs delete*](api::CustomerTelemetryNotificationConfigDeleteCall), [*telemetry notification configs list*](api::CustomerTelemetryNotificationConfigListCall), [*telemetry users get*](api::CustomerTelemetryUserGetCall) and [*telemetry users list*](api::CustomerTelemetryUserListCall) @@ -52,8 +52,8 @@ //! let r = hub.customers().apps_web_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use chromemanagement1::{ChromeManagement, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -122,10 +122,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -135,25 +135,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/chromepolicy1/src/lib.rs b/gen/chromepolicy1/src/lib.rs index 1ebcb7c99b..1198a21b4e 100644 --- a/gen/chromepolicy1/src/lib.rs +++ b/gen/chromepolicy1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/chromepolicy1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ChromePolicy) ... +//! Handle the following *Resources* with ease from the central [hub](ChromePolicy) ... //! //! * customers //! * [*policies groups batch delete*](api::CustomerPolicyGroupBatchDeleteCall), [*policies groups batch modify*](api::CustomerPolicyGroupBatchModifyCall), [*policies groups list group priority ordering*](api::CustomerPolicyGroupListGroupPriorityOrderingCall), [*policies groups update group priority ordering*](api::CustomerPolicyGroupUpdateGroupPriorityOrderingCall), [*policies networks define certificate*](api::CustomerPolicyNetworkDefineCertificateCall), [*policies networks define network*](api::CustomerPolicyNetworkDefineNetworkCall), [*policies networks remove certificate*](api::CustomerPolicyNetworkRemoveCertificateCall), [*policies networks remove network*](api::CustomerPolicyNetworkRemoveNetworkCall), [*policies orgunits batch inherit*](api::CustomerPolicyOrgunitBatchInheritCall), [*policies orgunits batch modify*](api::CustomerPolicyOrgunitBatchModifyCall), [*policies resolve*](api::CustomerPolicyResolveCall), [*policy schemas get*](api::CustomerPolicySchemaGetCall) and [*policy schemas list*](api::CustomerPolicySchemaListCall) @@ -60,8 +60,8 @@ //! let r = hub.customers().policies_orgunits_batch_modify(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use chromepolicy1::{ChromePolicy, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/chromeuxreport1/src/api.rs b/gen/chromeuxreport1/src/api.rs index 33a90814ac..6017f75b7c 100644 --- a/gen/chromeuxreport1/src/api.rs +++ b/gen/chromeuxreport1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use chromeuxreport1::{ChromeUXReport, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/chromeuxreport1/src/lib.rs b/gen/chromeuxreport1/src/lib.rs index c414b16ab5..65f9f2405e 100644 --- a/gen/chromeuxreport1/src/lib.rs +++ b/gen/chromeuxreport1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/chromeuxreport1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ChromeUXReport) ... +//! Handle the following *Resources* with ease from the central [hub](ChromeUXReport) ... //! //! * [records](api::Record) //! * [*query history record*](api::RecordQueryHistoryRecordCall) and [*query record*](api::RecordQueryRecordCall) @@ -51,8 +51,8 @@ //! let r = hub.records().query_record(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use chromeuxreport1::{ChromeUXReport, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/classroom1/src/lib.rs b/gen/classroom1/src/lib.rs index e68b49d646..7af9d42e0d 100644 --- a/gen/classroom1/src/lib.rs +++ b/gen/classroom1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/classroom1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Classroom) ... +//! Handle the following *Resources* with ease from the central [hub](Classroom) ... //! //! * [courses](api::Course) //! * [*aliases create*](api::CourseAliasCreateCall), [*aliases delete*](api::CourseAliasDeleteCall), [*aliases list*](api::CourseAliasListCall), [*announcements create*](api::CourseAnnouncementCreateCall), [*announcements delete*](api::CourseAnnouncementDeleteCall), [*announcements get*](api::CourseAnnouncementGetCall), [*announcements list*](api::CourseAnnouncementListCall), [*announcements modify assignees*](api::CourseAnnouncementModifyAssigneeCall), [*announcements patch*](api::CourseAnnouncementPatchCall), [*course work create*](api::CourseCourseWorkCreateCall), [*course work delete*](api::CourseCourseWorkDeleteCall), [*course work get*](api::CourseCourseWorkGetCall), [*course work list*](api::CourseCourseWorkListCall), [*course work modify assignees*](api::CourseCourseWorkModifyAssigneeCall), [*course work patch*](api::CourseCourseWorkPatchCall), [*course work student submissions get*](api::CourseCourseWorkStudentSubmissionGetCall), [*course work student submissions list*](api::CourseCourseWorkStudentSubmissionListCall), [*course work student submissions modify attachments*](api::CourseCourseWorkStudentSubmissionModifyAttachmentCall), [*course work student submissions patch*](api::CourseCourseWorkStudentSubmissionPatchCall), [*course work student submissions reclaim*](api::CourseCourseWorkStudentSubmissionReclaimCall), [*course work student submissions return*](api::CourseCourseWorkStudentSubmissionReturnCall), [*course work student submissions turn in*](api::CourseCourseWorkStudentSubmissionTurnInCall), [*course work materials create*](api::CourseCourseWorkMaterialCreateCall), [*course work materials delete*](api::CourseCourseWorkMaterialDeleteCall), [*course work materials get*](api::CourseCourseWorkMaterialGetCall), [*course work materials list*](api::CourseCourseWorkMaterialListCall), [*course work materials patch*](api::CourseCourseWorkMaterialPatchCall), [*create*](api::CourseCreateCall), [*delete*](api::CourseDeleteCall), [*get*](api::CourseGetCall), [*list*](api::CourseListCall), [*patch*](api::CoursePatchCall), [*students create*](api::CourseStudentCreateCall), [*students delete*](api::CourseStudentDeleteCall), [*students get*](api::CourseStudentGetCall), [*students list*](api::CourseStudentListCall), [*teachers create*](api::CourseTeacherCreateCall), [*teachers delete*](api::CourseTeacherDeleteCall), [*teachers get*](api::CourseTeacherGetCall), [*teachers list*](api::CourseTeacherListCall), [*topics create*](api::CourseTopicCreateCall), [*topics delete*](api::CourseTopicDeleteCall), [*topics get*](api::CourseTopicGetCall), [*topics list*](api::CourseTopicListCall), [*topics patch*](api::CourseTopicPatchCall) and [*update*](api::CourseUpdateCall) @@ -101,8 +101,8 @@ //! let r = hub.courses().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -130,12 +130,12 @@ //! use std::default::Default; //! use classroom1::{Classroom, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -176,10 +176,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -189,25 +189,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudasset1/src/lib.rs b/gen/cloudasset1/src/lib.rs index 48dc373028..ae8952257f 100644 --- a/gen/cloudasset1/src/lib.rs +++ b/gen/cloudasset1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudasset1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudAsset) ... +//! Handle the following *Resources* with ease from the central [hub](CloudAsset) ... //! //! * [assets](api::Asset) //! * [*list*](api::AssetListCall) @@ -75,8 +75,8 @@ //! let r = hub.feeds().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -105,12 +105,12 @@ //! use std::default::Default; //! use cloudasset1::{CloudAsset, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -151,10 +151,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -164,25 +164,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudasset1_beta1/src/lib.rs b/gen/cloudasset1_beta1/src/lib.rs index c67dcc900b..094041bdcf 100644 --- a/gen/cloudasset1_beta1/src/lib.rs +++ b/gen/cloudasset1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudasset1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudAsset) ... +//! Handle the following *Resources* with ease from the central [hub](CloudAsset) ... //! //! * folders //! * [*export assets*](api::FolderExportAssetCall) and [*operations get*](api::FolderOperationGetCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().export_assets(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use cloudasset1_beta1::{CloudAsset, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudbilling1/src/lib.rs b/gen/cloudbilling1/src/lib.rs index a45af5e617..ac2264fc74 100644 --- a/gen/cloudbilling1/src/lib.rs +++ b/gen/cloudbilling1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudbilling1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Cloudbilling) ... +//! Handle the following *Resources* with ease from the central [hub](Cloudbilling) ... //! //! * [billing accounts](api::BillingAccount) //! * [*create*](api::BillingAccountCreateCall), [*get*](api::BillingAccountGetCall), [*get iam policy*](api::BillingAccountGetIamPolicyCall), [*list*](api::BillingAccountListCall), [*move*](api::BillingAccountMoveCall), [*patch*](api::BillingAccountPatchCall), [*projects list*](api::BillingAccountProjectListCall), [*set iam policy*](api::BillingAccountSetIamPolicyCall), [*sub accounts create*](api::BillingAccountSubAccountCreateCall), [*sub accounts list*](api::BillingAccountSubAccountListCall) and [*test iam permissions*](api::BillingAccountTestIamPermissionCall) @@ -68,8 +68,8 @@ //! let r = hub.organizations().billing_accounts_move(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -97,12 +97,12 @@ //! use std::default::Default; //! use cloudbilling1::{Cloudbilling, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudbuild1/src/lib.rs b/gen/cloudbuild1/src/lib.rs index 2fe7108899..eb3d3cbf5c 100644 --- a/gen/cloudbuild1/src/lib.rs +++ b/gen/cloudbuild1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudbuild1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudBuild) ... +//! Handle the following *Resources* with ease from the central [hub](CloudBuild) ... //! //! * github dot com webhook //! * [*receive*](api::GithubDotComWebhookReceiveCall) @@ -86,8 +86,8 @@ //! let r = hub.projects().triggers_run(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -116,12 +116,12 @@ //! use std::default::Default; //! use cloudbuild1::{CloudBuild, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -164,10 +164,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -177,25 +177,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudchannel1/src/lib.rs b/gen/cloudchannel1/src/lib.rs index 41ecdb4ee4..86b550190b 100644 --- a/gen/cloudchannel1/src/lib.rs +++ b/gen/cloudchannel1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudchannel1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Cloudchannel) ... +//! Handle the following *Resources* with ease from the central [hub](Cloudchannel) ... //! //! * accounts //! * [*channel partner links channel partner repricing configs create*](api::AccountChannelPartnerLinkChannelPartnerRepricingConfigCreateCall), [*channel partner links channel partner repricing configs delete*](api::AccountChannelPartnerLinkChannelPartnerRepricingConfigDeleteCall), [*channel partner links channel partner repricing configs get*](api::AccountChannelPartnerLinkChannelPartnerRepricingConfigGetCall), [*channel partner links channel partner repricing configs list*](api::AccountChannelPartnerLinkChannelPartnerRepricingConfigListCall), [*channel partner links channel partner repricing configs patch*](api::AccountChannelPartnerLinkChannelPartnerRepricingConfigPatchCall), [*channel partner links create*](api::AccountChannelPartnerLinkCreateCall), [*channel partner links customers create*](api::AccountChannelPartnerLinkCustomerCreateCall), [*channel partner links customers delete*](api::AccountChannelPartnerLinkCustomerDeleteCall), [*channel partner links customers get*](api::AccountChannelPartnerLinkCustomerGetCall), [*channel partner links customers import*](api::AccountChannelPartnerLinkCustomerImportCall), [*channel partner links customers list*](api::AccountChannelPartnerLinkCustomerListCall), [*channel partner links customers patch*](api::AccountChannelPartnerLinkCustomerPatchCall), [*channel partner links get*](api::AccountChannelPartnerLinkGetCall), [*channel partner links list*](api::AccountChannelPartnerLinkListCall), [*channel partner links patch*](api::AccountChannelPartnerLinkPatchCall), [*check cloud identity accounts exist*](api::AccountCheckCloudIdentityAccountsExistCall), [*customers create*](api::AccountCustomerCreateCall), [*customers customer repricing configs create*](api::AccountCustomerCustomerRepricingConfigCreateCall), [*customers customer repricing configs delete*](api::AccountCustomerCustomerRepricingConfigDeleteCall), [*customers customer repricing configs get*](api::AccountCustomerCustomerRepricingConfigGetCall), [*customers customer repricing configs list*](api::AccountCustomerCustomerRepricingConfigListCall), [*customers customer repricing configs patch*](api::AccountCustomerCustomerRepricingConfigPatchCall), [*customers delete*](api::AccountCustomerDeleteCall), [*customers entitlements activate*](api::AccountCustomerEntitlementActivateCall), [*customers entitlements cancel*](api::AccountCustomerEntitlementCancelCall), [*customers entitlements change offer*](api::AccountCustomerEntitlementChangeOfferCall), [*customers entitlements change parameters*](api::AccountCustomerEntitlementChangeParameterCall), [*customers entitlements change renewal settings*](api::AccountCustomerEntitlementChangeRenewalSettingCall), [*customers entitlements create*](api::AccountCustomerEntitlementCreateCall), [*customers entitlements get*](api::AccountCustomerEntitlementGetCall), [*customers entitlements list*](api::AccountCustomerEntitlementListCall), [*customers entitlements list entitlement changes*](api::AccountCustomerEntitlementListEntitlementChangeCall), [*customers entitlements lookup offer*](api::AccountCustomerEntitlementLookupOfferCall), [*customers entitlements start paid service*](api::AccountCustomerEntitlementStartPaidServiceCall), [*customers entitlements suspend*](api::AccountCustomerEntitlementSuspendCall), [*customers get*](api::AccountCustomerGetCall), [*customers import*](api::AccountCustomerImportCall), [*customers list*](api::AccountCustomerListCall), [*customers list purchasable offers*](api::AccountCustomerListPurchasableOfferCall), [*customers list purchasable skus*](api::AccountCustomerListPurchasableSkuCall), [*customers patch*](api::AccountCustomerPatchCall), [*customers provision cloud identity*](api::AccountCustomerProvisionCloudIdentityCall), [*customers query eligible billing accounts*](api::AccountCustomerQueryEligibleBillingAccountCall), [*customers transfer entitlements*](api::AccountCustomerTransferEntitlementCall), [*customers transfer entitlements to google*](api::AccountCustomerTransferEntitlementsToGoogleCall), [*list subscribers*](api::AccountListSubscriberCall), [*list transferable offers*](api::AccountListTransferableOfferCall), [*list transferable skus*](api::AccountListTransferableSkuCall), [*offers list*](api::AccountOfferListCall), [*register*](api::AccountRegisterCall), [*report jobs fetch report results*](api::AccountReportJobFetchReportResultCall), [*reports list*](api::AccountReportListCall), [*reports run*](api::AccountReportRunCall), [*sku groups billable skus list*](api::AccountSkuGroupBillableSkuListCall), [*sku groups list*](api::AccountSkuGroupListCall) and [*unregister*](api::AccountUnregisterCall) @@ -66,8 +66,8 @@ //! let r = hub.operations().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use cloudchannel1::{Cloudchannel, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -142,10 +142,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -155,25 +155,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/clouddebugger2/src/lib.rs b/gen/clouddebugger2/src/lib.rs index 370bc16076..1b3d8ca1c4 100644 --- a/gen/clouddebugger2/src/lib.rs +++ b/gen/clouddebugger2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/clouddebugger2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudDebugger) ... +//! Handle the following *Resources* with ease from the central [hub](CloudDebugger) ... //! //! * controller //! * [*debuggees breakpoints list*](api::ControllerDebuggeeBreakpointListCall), [*debuggees breakpoints update*](api::ControllerDebuggeeBreakpointUpdateCall) and [*debuggees register*](api::ControllerDebuggeeRegisterCall) @@ -52,8 +52,8 @@ //! let r = hub.debugger().debuggees_breakpoints_set(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use clouddebugger2::{CloudDebugger, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/clouddeploy1/src/lib.rs b/gen/clouddeploy1/src/lib.rs index 92b013e4e2..ad48420140 100644 --- a/gen/clouddeploy1/src/lib.rs +++ b/gen/clouddeploy1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/clouddeploy1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudDeploy) ... +//! Handle the following *Resources* with ease from the central [hub](CloudDeploy) ... //! //! * projects //! * [*locations custom target types create*](api::ProjectLocationCustomTargetTypeCreateCall), [*locations custom target types delete*](api::ProjectLocationCustomTargetTypeDeleteCall), [*locations custom target types get*](api::ProjectLocationCustomTargetTypeGetCall), [*locations custom target types get iam policy*](api::ProjectLocationCustomTargetTypeGetIamPolicyCall), [*locations custom target types list*](api::ProjectLocationCustomTargetTypeListCall), [*locations custom target types patch*](api::ProjectLocationCustomTargetTypePatchCall), [*locations custom target types set iam policy*](api::ProjectLocationCustomTargetTypeSetIamPolicyCall), [*locations delivery pipelines automation runs cancel*](api::ProjectLocationDeliveryPipelineAutomationRunCancelCall), [*locations delivery pipelines automation runs get*](api::ProjectLocationDeliveryPipelineAutomationRunGetCall), [*locations delivery pipelines automation runs list*](api::ProjectLocationDeliveryPipelineAutomationRunListCall), [*locations delivery pipelines automations create*](api::ProjectLocationDeliveryPipelineAutomationCreateCall), [*locations delivery pipelines automations delete*](api::ProjectLocationDeliveryPipelineAutomationDeleteCall), [*locations delivery pipelines automations get*](api::ProjectLocationDeliveryPipelineAutomationGetCall), [*locations delivery pipelines automations list*](api::ProjectLocationDeliveryPipelineAutomationListCall), [*locations delivery pipelines automations patch*](api::ProjectLocationDeliveryPipelineAutomationPatchCall), [*locations delivery pipelines create*](api::ProjectLocationDeliveryPipelineCreateCall), [*locations delivery pipelines delete*](api::ProjectLocationDeliveryPipelineDeleteCall), [*locations delivery pipelines get*](api::ProjectLocationDeliveryPipelineGetCall), [*locations delivery pipelines get iam policy*](api::ProjectLocationDeliveryPipelineGetIamPolicyCall), [*locations delivery pipelines list*](api::ProjectLocationDeliveryPipelineListCall), [*locations delivery pipelines patch*](api::ProjectLocationDeliveryPipelinePatchCall), [*locations delivery pipelines releases abandon*](api::ProjectLocationDeliveryPipelineReleaseAbandonCall), [*locations delivery pipelines releases create*](api::ProjectLocationDeliveryPipelineReleaseCreateCall), [*locations delivery pipelines releases get*](api::ProjectLocationDeliveryPipelineReleaseGetCall), [*locations delivery pipelines releases list*](api::ProjectLocationDeliveryPipelineReleaseListCall), [*locations delivery pipelines releases rollouts advance*](api::ProjectLocationDeliveryPipelineReleaseRolloutAdvanceCall), [*locations delivery pipelines releases rollouts approve*](api::ProjectLocationDeliveryPipelineReleaseRolloutApproveCall), [*locations delivery pipelines releases rollouts cancel*](api::ProjectLocationDeliveryPipelineReleaseRolloutCancelCall), [*locations delivery pipelines releases rollouts create*](api::ProjectLocationDeliveryPipelineReleaseRolloutCreateCall), [*locations delivery pipelines releases rollouts get*](api::ProjectLocationDeliveryPipelineReleaseRolloutGetCall), [*locations delivery pipelines releases rollouts ignore job*](api::ProjectLocationDeliveryPipelineReleaseRolloutIgnoreJobCall), [*locations delivery pipelines releases rollouts job runs get*](api::ProjectLocationDeliveryPipelineReleaseRolloutJobRunGetCall), [*locations delivery pipelines releases rollouts job runs list*](api::ProjectLocationDeliveryPipelineReleaseRolloutJobRunListCall), [*locations delivery pipelines releases rollouts job runs terminate*](api::ProjectLocationDeliveryPipelineReleaseRolloutJobRunTerminateCall), [*locations delivery pipelines releases rollouts list*](api::ProjectLocationDeliveryPipelineReleaseRolloutListCall), [*locations delivery pipelines releases rollouts retry job*](api::ProjectLocationDeliveryPipelineReleaseRolloutRetryJobCall), [*locations delivery pipelines rollback target*](api::ProjectLocationDeliveryPipelineRollbackTargetCall), [*locations delivery pipelines set iam policy*](api::ProjectLocationDeliveryPipelineSetIamPolicyCall), [*locations delivery pipelines test iam permissions*](api::ProjectLocationDeliveryPipelineTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations get config*](api::ProjectLocationGetConfigCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations targets create*](api::ProjectLocationTargetCreateCall), [*locations targets delete*](api::ProjectLocationTargetDeleteCall), [*locations targets get*](api::ProjectLocationTargetGetCall), [*locations targets get iam policy*](api::ProjectLocationTargetGetIamPolicyCall), [*locations targets list*](api::ProjectLocationTargetListCall), [*locations targets patch*](api::ProjectLocationTargetPatchCall), [*locations targets set iam policy*](api::ProjectLocationTargetSetIamPolicyCall) and [*locations targets test iam permissions*](api::ProjectLocationTargetTestIamPermissionCall) @@ -64,8 +64,8 @@ //! let r = hub.projects().locations_targets_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -94,12 +94,12 @@ //! use std::default::Default; //! use clouddeploy1::{CloudDeploy, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -144,10 +144,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -157,25 +157,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/clouderrorreporting1_beta1/src/lib.rs b/gen/clouderrorreporting1_beta1/src/lib.rs index 0bb2b7e1bb..f08b581ef8 100644 --- a/gen/clouderrorreporting1_beta1/src/lib.rs +++ b/gen/clouderrorreporting1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/clouderrorreporting1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Clouderrorreporting) ... +//! Handle the following *Resources* with ease from the central [hub](Clouderrorreporting) ... //! //! * projects //! * [*delete events*](api::ProjectDeleteEventCall), [*events list*](api::ProjectEventListCall), [*events report*](api::ProjectEventReportCall), [*group stats list*](api::ProjectGroupStatListCall), [*groups get*](api::ProjectGroupGetCall) and [*groups update*](api::ProjectGroupUpdateCall) @@ -51,8 +51,8 @@ //! let r = hub.projects().groups_update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use clouderrorreporting1_beta1::{Clouderrorreporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudfunctions1/src/lib.rs b/gen/cloudfunctions1/src/lib.rs index fed774db42..528fc1876b 100644 --- a/gen/cloudfunctions1/src/lib.rs +++ b/gen/cloudfunctions1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudfunctions1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudFunctions) ... +//! Handle the following *Resources* with ease from the central [hub](CloudFunctions) ... //! //! * [operations](api::Operation) //! * [*get*](api::OperationGetCall) and [*list*](api::OperationListCall) @@ -56,8 +56,8 @@ //! let r = hub.projects().locations_functions_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use cloudfunctions1::{CloudFunctions, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudidentity1/src/lib.rs b/gen/cloudidentity1/src/lib.rs index 9f187b5c45..afc8767cf4 100644 --- a/gen/cloudidentity1/src/lib.rs +++ b/gen/cloudidentity1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudidentity1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudIdentity) ... +//! Handle the following *Resources* with ease from the central [hub](CloudIdentity) ... //! //! * customers //! * [*userinvitations cancel*](api::CustomerUserinvitationCancelCall), [*userinvitations get*](api::CustomerUserinvitationGetCall), [*userinvitations is invitable user*](api::CustomerUserinvitationIsInvitableUserCall), [*userinvitations list*](api::CustomerUserinvitationListCall) and [*userinvitations send*](api::CustomerUserinvitationSendCall) @@ -84,8 +84,8 @@ //! let r = hub.inbound_sso_assignments().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -114,12 +114,12 @@ //! use std::default::Default; //! use cloudidentity1::{CloudIdentity, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -162,10 +162,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -175,25 +175,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudiot1/src/lib.rs b/gen/cloudiot1/src/lib.rs index 09d7b7911d..8d3325928c 100644 --- a/gen/cloudiot1/src/lib.rs +++ b/gen/cloudiot1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudiot1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudIot) ... +//! Handle the following *Resources* with ease from the central [hub](CloudIot) ... //! //! * projects //! * [*locations registries bind device to gateway*](api::ProjectLocationRegistryBindDeviceToGatewayCall), [*locations registries create*](api::ProjectLocationRegistryCreateCall), [*locations registries delete*](api::ProjectLocationRegistryDeleteCall), [*locations registries devices config versions list*](api::ProjectLocationRegistryDeviceConfigVersionListCall), [*locations registries devices create*](api::ProjectLocationRegistryDeviceCreateCall), [*locations registries devices delete*](api::ProjectLocationRegistryDeviceDeleteCall), [*locations registries devices get*](api::ProjectLocationRegistryDeviceGetCall), [*locations registries devices list*](api::ProjectLocationRegistryDeviceListCall), [*locations registries devices modify cloud to device config*](api::ProjectLocationRegistryDeviceModifyCloudToDeviceConfigCall), [*locations registries devices patch*](api::ProjectLocationRegistryDevicePatchCall), [*locations registries devices send command to device*](api::ProjectLocationRegistryDeviceSendCommandToDeviceCall), [*locations registries devices states list*](api::ProjectLocationRegistryDeviceStateListCall), [*locations registries get*](api::ProjectLocationRegistryGetCall), [*locations registries get iam policy*](api::ProjectLocationRegistryGetIamPolicyCall), [*locations registries groups devices list*](api::ProjectLocationRegistryGroupDeviceListCall), [*locations registries groups get iam policy*](api::ProjectLocationRegistryGroupGetIamPolicyCall), [*locations registries groups set iam policy*](api::ProjectLocationRegistryGroupSetIamPolicyCall), [*locations registries groups test iam permissions*](api::ProjectLocationRegistryGroupTestIamPermissionCall), [*locations registries list*](api::ProjectLocationRegistryListCall), [*locations registries patch*](api::ProjectLocationRegistryPatchCall), [*locations registries set iam policy*](api::ProjectLocationRegistrySetIamPolicyCall), [*locations registries test iam permissions*](api::ProjectLocationRegistryTestIamPermissionCall) and [*locations registries unbind device from gateway*](api::ProjectLocationRegistryUnbindDeviceFromGatewayCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().locations_registries_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use cloudiot1::{CloudIot, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudkms1/src/lib.rs b/gen/cloudkms1/src/lib.rs index 4b5c91e6e0..c0719726d6 100644 --- a/gen/cloudkms1/src/lib.rs +++ b/gen/cloudkms1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudkms1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudKMS) ... +//! Handle the following *Resources* with ease from the central [hub](CloudKMS) ... //! //! * projects //! * [*locations ekm config get iam policy*](api::ProjectLocationEkmConfigGetIamPolicyCall), [*locations ekm config set iam policy*](api::ProjectLocationEkmConfigSetIamPolicyCall), [*locations ekm config test iam permissions*](api::ProjectLocationEkmConfigTestIamPermissionCall), [*locations ekm connections create*](api::ProjectLocationEkmConnectionCreateCall), [*locations ekm connections get*](api::ProjectLocationEkmConnectionGetCall), [*locations ekm connections get iam policy*](api::ProjectLocationEkmConnectionGetIamPolicyCall), [*locations ekm connections list*](api::ProjectLocationEkmConnectionListCall), [*locations ekm connections patch*](api::ProjectLocationEkmConnectionPatchCall), [*locations ekm connections set iam policy*](api::ProjectLocationEkmConnectionSetIamPolicyCall), [*locations ekm connections test iam permissions*](api::ProjectLocationEkmConnectionTestIamPermissionCall), [*locations ekm connections verify connectivity*](api::ProjectLocationEkmConnectionVerifyConnectivityCall), [*locations generate random bytes*](api::ProjectLocationGenerateRandomByteCall), [*locations get*](api::ProjectLocationGetCall), [*locations get ekm config*](api::ProjectLocationGetEkmConfigCall), [*locations key rings create*](api::ProjectLocationKeyRingCreateCall), [*locations key rings crypto keys create*](api::ProjectLocationKeyRingCryptoKeyCreateCall), [*locations key rings crypto keys crypto key versions asymmetric decrypt*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionAsymmetricDecryptCall), [*locations key rings crypto keys crypto key versions asymmetric sign*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionAsymmetricSignCall), [*locations key rings crypto keys crypto key versions create*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionCreateCall), [*locations key rings crypto keys crypto key versions destroy*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionDestroyCall), [*locations key rings crypto keys crypto key versions get*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionGetCall), [*locations key rings crypto keys crypto key versions get public key*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionGetPublicKeyCall), [*locations key rings crypto keys crypto key versions import*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionImportCall), [*locations key rings crypto keys crypto key versions list*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionListCall), [*locations key rings crypto keys crypto key versions mac sign*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionMacSignCall), [*locations key rings crypto keys crypto key versions mac verify*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionMacVerifyCall), [*locations key rings crypto keys crypto key versions patch*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionPatchCall), [*locations key rings crypto keys crypto key versions raw decrypt*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionRawDecryptCall), [*locations key rings crypto keys crypto key versions raw encrypt*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionRawEncryptCall), [*locations key rings crypto keys crypto key versions restore*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionRestoreCall), [*locations key rings crypto keys decrypt*](api::ProjectLocationKeyRingCryptoKeyDecryptCall), [*locations key rings crypto keys encrypt*](api::ProjectLocationKeyRingCryptoKeyEncryptCall), [*locations key rings crypto keys get*](api::ProjectLocationKeyRingCryptoKeyGetCall), [*locations key rings crypto keys get iam policy*](api::ProjectLocationKeyRingCryptoKeyGetIamPolicyCall), [*locations key rings crypto keys list*](api::ProjectLocationKeyRingCryptoKeyListCall), [*locations key rings crypto keys patch*](api::ProjectLocationKeyRingCryptoKeyPatchCall), [*locations key rings crypto keys set iam policy*](api::ProjectLocationKeyRingCryptoKeySetIamPolicyCall), [*locations key rings crypto keys test iam permissions*](api::ProjectLocationKeyRingCryptoKeyTestIamPermissionCall), [*locations key rings crypto keys update primary version*](api::ProjectLocationKeyRingCryptoKeyUpdatePrimaryVersionCall), [*locations key rings get*](api::ProjectLocationKeyRingGetCall), [*locations key rings get iam policy*](api::ProjectLocationKeyRingGetIamPolicyCall), [*locations key rings import jobs create*](api::ProjectLocationKeyRingImportJobCreateCall), [*locations key rings import jobs get*](api::ProjectLocationKeyRingImportJobGetCall), [*locations key rings import jobs get iam policy*](api::ProjectLocationKeyRingImportJobGetIamPolicyCall), [*locations key rings import jobs list*](api::ProjectLocationKeyRingImportJobListCall), [*locations key rings import jobs set iam policy*](api::ProjectLocationKeyRingImportJobSetIamPolicyCall), [*locations key rings import jobs test iam permissions*](api::ProjectLocationKeyRingImportJobTestIamPermissionCall), [*locations key rings list*](api::ProjectLocationKeyRingListCall), [*locations key rings set iam policy*](api::ProjectLocationKeyRingSetIamPolicyCall), [*locations key rings test iam permissions*](api::ProjectLocationKeyRingTestIamPermissionCall), [*locations list*](api::ProjectLocationListCall) and [*locations update ekm config*](api::ProjectLocationUpdateEkmConfigCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().locations_key_rings_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use cloudkms1::{CloudKMS, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudkms1_beta1/src/lib.rs b/gen/cloudkms1_beta1/src/lib.rs index ebf23fda72..7f1ff627f0 100644 --- a/gen/cloudkms1_beta1/src/lib.rs +++ b/gen/cloudkms1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudkms1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudKMS) ... +//! Handle the following *Resources* with ease from the central [hub](CloudKMS) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations key rings create*](api::ProjectLocationKeyRingCreateCall), [*locations key rings crypto keys create*](api::ProjectLocationKeyRingCryptoKeyCreateCall), [*locations key rings crypto keys crypto key versions create*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionCreateCall), [*locations key rings crypto keys crypto key versions destroy*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionDestroyCall), [*locations key rings crypto keys crypto key versions get*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionGetCall), [*locations key rings crypto keys crypto key versions list*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionListCall), [*locations key rings crypto keys crypto key versions patch*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionPatchCall), [*locations key rings crypto keys crypto key versions restore*](api::ProjectLocationKeyRingCryptoKeyCryptoKeyVersionRestoreCall), [*locations key rings crypto keys decrypt*](api::ProjectLocationKeyRingCryptoKeyDecryptCall), [*locations key rings crypto keys encrypt*](api::ProjectLocationKeyRingCryptoKeyEncryptCall), [*locations key rings crypto keys get*](api::ProjectLocationKeyRingCryptoKeyGetCall), [*locations key rings crypto keys get iam policy*](api::ProjectLocationKeyRingCryptoKeyGetIamPolicyCall), [*locations key rings crypto keys list*](api::ProjectLocationKeyRingCryptoKeyListCall), [*locations key rings crypto keys patch*](api::ProjectLocationKeyRingCryptoKeyPatchCall), [*locations key rings crypto keys set iam policy*](api::ProjectLocationKeyRingCryptoKeySetIamPolicyCall), [*locations key rings crypto keys test iam permissions*](api::ProjectLocationKeyRingCryptoKeyTestIamPermissionCall), [*locations key rings crypto keys update primary version*](api::ProjectLocationKeyRingCryptoKeyUpdatePrimaryVersionCall), [*locations key rings get*](api::ProjectLocationKeyRingGetCall), [*locations key rings get iam policy*](api::ProjectLocationKeyRingGetIamPolicyCall), [*locations key rings list*](api::ProjectLocationKeyRingListCall), [*locations key rings set iam policy*](api::ProjectLocationKeyRingSetIamPolicyCall), [*locations key rings test iam permissions*](api::ProjectLocationKeyRingTestIamPermissionCall) and [*locations list*](api::ProjectLocationListCall) @@ -54,8 +54,8 @@ //! let r = hub.projects().locations_key_rings_crypto_keys_crypto_key_versions_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use cloudkms1_beta1::{CloudKMS, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudlatencytest2/src/lib.rs b/gen/cloudlatencytest2/src/lib.rs index 12ee2c3714..549b34670e 100644 --- a/gen/cloudlatencytest2/src/lib.rs +++ b/gen/cloudlatencytest2/src/lib.rs @@ -6,7 +6,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudlatencytest2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Cloudlatencytest) ... +//! Handle the following *Resources* with ease from the central [hub](Cloudlatencytest) ... //! //! * statscollection //! * [*updateaggregatedstats*](api::StatscollectionUpdateaggregatedstatCall) and [*updatestats*](api::StatscollectionUpdatestatCall) @@ -47,8 +47,8 @@ //! let r = hub.statscollection().updatestats(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -77,12 +77,12 @@ //! use std::default::Default; //! use cloudlatencytest2::{Cloudlatencytest, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -123,10 +123,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -136,25 +136,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudmonitoring2_beta2/src/lib.rs b/gen/cloudmonitoring2_beta2/src/lib.rs index a576f6a654..a4c0d3cea6 100644 --- a/gen/cloudmonitoring2_beta2/src/lib.rs +++ b/gen/cloudmonitoring2_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudmonitoring2_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudMonitoring) ... +//! Handle the following *Resources* with ease from the central [hub](CloudMonitoring) ... //! //! * [metric descriptors](api::MetricDescriptor) //! * [*create*](api::MetricDescriptorCreateCall), [*delete*](api::MetricDescriptorDeleteCall) and [*list*](api::MetricDescriptorListCall) @@ -56,8 +56,8 @@ //! let r = hub.metric_descriptors().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use cloudmonitoring2_beta2::{CloudMonitoring, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudprivatecatalog1_beta1/src/lib.rs b/gen/cloudprivatecatalog1_beta1/src/lib.rs index 9e6e3ce4e7..1cbbb6d272 100644 --- a/gen/cloudprivatecatalog1_beta1/src/lib.rs +++ b/gen/cloudprivatecatalog1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudprivatecatalog1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudPrivateCatalog) ... +//! Handle the following *Resources* with ease from the central [hub](CloudPrivateCatalog) ... //! //! * folders //! * [*catalogs search*](api::FolderCatalogSearchCall), [*products search*](api::FolderProductSearchCall) and [*versions search*](api::FolderVersionSearchCall) @@ -56,8 +56,8 @@ //! let r = hub.projects().catalogs_search(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use cloudprivatecatalog1_beta1::{CloudPrivateCatalog, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudprivatecatalogproducer1_beta1/src/lib.rs b/gen/cloudprivatecatalogproducer1_beta1/src/lib.rs index bca4a8ee2b..5302e74c19 100644 --- a/gen/cloudprivatecatalogproducer1_beta1/src/lib.rs +++ b/gen/cloudprivatecatalogproducer1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudprivatecatalogproducer1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudPrivateCatalogProducer) ... +//! Handle the following *Resources* with ease from the central [hub](CloudPrivateCatalogProducer) ... //! //! * catalogs //! * [*associations create*](api::CatalogAssociationCreateCall), [*associations delete*](api::CatalogAssociationDeleteCall), [*associations get*](api::CatalogAssociationGetCall), [*associations list*](api::CatalogAssociationListCall), [*create*](api::CatalogCreateCall), [*delete*](api::CatalogDeleteCall), [*get*](api::CatalogGetCall), [*get iam policy*](api::CatalogGetIamPolicyCall), [*list*](api::CatalogListCall), [*patch*](api::CatalogPatchCall), [*products copy*](api::CatalogProductCopyCall), [*products create*](api::CatalogProductCreateCall), [*products delete*](api::CatalogProductDeleteCall), [*products get*](api::CatalogProductGetCall), [*products icons upload*](api::CatalogProductIconUploadCall), [*products list*](api::CatalogProductListCall), [*products patch*](api::CatalogProductPatchCall), [*products versions create*](api::CatalogProductVersionCreateCall), [*products versions delete*](api::CatalogProductVersionDeleteCall), [*products versions get*](api::CatalogProductVersionGetCall), [*products versions list*](api::CatalogProductVersionListCall), [*products versions patch*](api::CatalogProductVersionPatchCall), [*set iam policy*](api::CatalogSetIamPolicyCall), [*test iam permissions*](api::CatalogTestIamPermissionCall) and [*undelete*](api::CatalogUndeleteCall) @@ -57,8 +57,8 @@ //! let r = hub.operations().delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use cloudprivatecatalogproducer1_beta1::{CloudPrivateCatalogProducer, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudprofiler2/src/lib.rs b/gen/cloudprofiler2/src/lib.rs index be34592b0e..a8e142fbd7 100644 --- a/gen/cloudprofiler2/src/lib.rs +++ b/gen/cloudprofiler2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudprofiler2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudProfiler) ... +//! Handle the following *Resources* with ease from the central [hub](CloudProfiler) ... //! //! * projects //! * [*profiles create*](api::ProjectProfileCreateCall), [*profiles create offline*](api::ProjectProfileCreateOfflineCall), [*profiles list*](api::ProjectProfileListCall) and [*profiles patch*](api::ProjectProfilePatchCall) @@ -52,8 +52,8 @@ //! let r = hub.projects().profiles_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use cloudprofiler2::{CloudProfiler, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudresourcemanager1/src/lib.rs b/gen/cloudresourcemanager1/src/lib.rs index 48a707673b..6fb7370b4c 100644 --- a/gen/cloudresourcemanager1/src/lib.rs +++ b/gen/cloudresourcemanager1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudresourcemanager1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudResourceManager) ... +//! Handle the following *Resources* with ease from the central [hub](CloudResourceManager) ... //! //! * folders //! * [*clear org policy*](api::FolderClearOrgPolicyCall), [*get effective org policy*](api::FolderGetEffectiveOrgPolicyCall), [*get org policy*](api::FolderGetOrgPolicyCall), [*list available org policy constraints*](api::FolderListAvailableOrgPolicyConstraintCall), [*list org policies*](api::FolderListOrgPolicyCall) and [*set org policy*](api::FolderSetOrgPolicyCall) @@ -73,8 +73,8 @@ //! let r = hub.projects().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -102,12 +102,12 @@ //! use std::default::Default; //! use cloudresourcemanager1::{CloudResourceManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -146,10 +146,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -159,25 +159,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudresourcemanager1_beta1/src/lib.rs b/gen/cloudresourcemanager1_beta1/src/lib.rs index 7ecb13a18c..f0f3dacb42 100644 --- a/gen/cloudresourcemanager1_beta1/src/lib.rs +++ b/gen/cloudresourcemanager1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudresourcemanager1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudResourceManager) ... +//! Handle the following *Resources* with ease from the central [hub](CloudResourceManager) ... //! //! * [organizations](api::Organization) //! * [*get*](api::OrganizationGetCall), [*get iam policy*](api::OrganizationGetIamPolicyCall), [*list*](api::OrganizationListCall), [*set iam policy*](api::OrganizationSetIamPolicyCall), [*test iam permissions*](api::OrganizationTestIamPermissionCall) and [*update*](api::OrganizationUpdateCall) @@ -61,8 +61,8 @@ //! let r = hub.projects().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use cloudresourcemanager1_beta1::{CloudResourceManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudresourcemanager2/src/lib.rs b/gen/cloudresourcemanager2/src/lib.rs index 320beefb84..f4ea3a8a99 100644 --- a/gen/cloudresourcemanager2/src/lib.rs +++ b/gen/cloudresourcemanager2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudresourcemanager2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudResourceManager) ... +//! Handle the following *Resources* with ease from the central [hub](CloudResourceManager) ... //! //! * [folders](api::Folder) //! * [*create*](api::FolderCreateCall), [*delete*](api::FolderDeleteCall), [*get*](api::FolderGetCall), [*get iam policy*](api::FolderGetIamPolicyCall), [*list*](api::FolderListCall), [*move*](api::FolderMoveCall), [*patch*](api::FolderPatchCall), [*search*](api::FolderSearchCall), [*set iam policy*](api::FolderSetIamPolicyCall), [*test iam permissions*](api::FolderTestIamPermissionCall) and [*undelete*](api::FolderUndeleteCall) @@ -62,8 +62,8 @@ //! let r = hub.folders().undelete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use cloudresourcemanager2::{CloudResourceManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudresourcemanager3/src/lib.rs b/gen/cloudresourcemanager3/src/lib.rs index b0f6ada9d4..4dea128018 100644 --- a/gen/cloudresourcemanager3/src/lib.rs +++ b/gen/cloudresourcemanager3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudresourcemanager3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudResourceManager) ... +//! Handle the following *Resources* with ease from the central [hub](CloudResourceManager) ... //! //! * [effective tags](api::EffectiveTag) //! * [*list*](api::EffectiveTagListCall) @@ -86,8 +86,8 @@ //! let r = hub.tag_values().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -116,12 +116,12 @@ //! use std::default::Default; //! use cloudresourcemanager3::{CloudResourceManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -164,10 +164,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -177,25 +177,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudscheduler1/src/lib.rs b/gen/cloudscheduler1/src/lib.rs index aaf8e9763c..2d607c8ba1 100644 --- a/gen/cloudscheduler1/src/lib.rs +++ b/gen/cloudscheduler1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudscheduler1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudScheduler) ... +//! Handle the following *Resources* with ease from the central [hub](CloudScheduler) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations jobs create*](api::ProjectLocationJobCreateCall), [*locations jobs delete*](api::ProjectLocationJobDeleteCall), [*locations jobs get*](api::ProjectLocationJobGetCall), [*locations jobs list*](api::ProjectLocationJobListCall), [*locations jobs patch*](api::ProjectLocationJobPatchCall), [*locations jobs pause*](api::ProjectLocationJobPauseCall), [*locations jobs resume*](api::ProjectLocationJobResumeCall), [*locations jobs run*](api::ProjectLocationJobRunCall) and [*locations list*](api::ProjectLocationListCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_jobs_run(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use cloudscheduler1::{CloudScheduler, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudscheduler1_beta1/src/lib.rs b/gen/cloudscheduler1_beta1/src/lib.rs index b90a0eba90..33f4418cb9 100644 --- a/gen/cloudscheduler1_beta1/src/lib.rs +++ b/gen/cloudscheduler1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudscheduler1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudScheduler) ... +//! Handle the following *Resources* with ease from the central [hub](CloudScheduler) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations jobs create*](api::ProjectLocationJobCreateCall), [*locations jobs delete*](api::ProjectLocationJobDeleteCall), [*locations jobs get*](api::ProjectLocationJobGetCall), [*locations jobs list*](api::ProjectLocationJobListCall), [*locations jobs patch*](api::ProjectLocationJobPatchCall), [*locations jobs pause*](api::ProjectLocationJobPauseCall), [*locations jobs resume*](api::ProjectLocationJobResumeCall), [*locations jobs run*](api::ProjectLocationJobRunCall) and [*locations list*](api::ProjectLocationListCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_jobs_run(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use cloudscheduler1_beta1::{CloudScheduler, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudshell1/src/lib.rs b/gen/cloudshell1/src/lib.rs index 812e492681..e2cda5d20c 100644 --- a/gen/cloudshell1/src/lib.rs +++ b/gen/cloudshell1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudshell1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudShell) ... +//! Handle the following *Resources* with ease from the central [hub](CloudShell) ... //! //! * [operations](api::Operation) //! * [*cancel*](api::OperationCancelCall), [*delete*](api::OperationDeleteCall), [*get*](api::OperationGetCall) and [*list*](api::OperationListCall) @@ -59,8 +59,8 @@ //! let r = hub.users().environments_start(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use cloudshell1::{CloudShell, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudsupport2_beta/src/lib.rs b/gen/cloudsupport2_beta/src/lib.rs index 969d9ac5f1..945890f126 100644 --- a/gen/cloudsupport2_beta/src/lib.rs +++ b/gen/cloudsupport2_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudsupport2_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudSupport) ... +//! Handle the following *Resources* with ease from the central [hub](CloudSupport) ... //! //! * [case classifications](api::CaseClassification) //! * [*search*](api::CaseClassificationSearchCall) @@ -71,8 +71,8 @@ //! let r = hub.cases().search(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -100,12 +100,12 @@ //! use std::default::Default; //! use cloudsupport2_beta::{CloudSupport, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -145,10 +145,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -158,25 +158,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudtasks2/src/lib.rs b/gen/cloudtasks2/src/lib.rs index 55bdd40071..5170c5140c 100644 --- a/gen/cloudtasks2/src/lib.rs +++ b/gen/cloudtasks2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudtasks2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudTasks) ... +//! Handle the following *Resources* with ease from the central [hub](CloudTasks) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations get cmek config*](api::ProjectLocationGetCmekConfigCall), [*locations list*](api::ProjectLocationListCall), [*locations queues create*](api::ProjectLocationQueueCreateCall), [*locations queues delete*](api::ProjectLocationQueueDeleteCall), [*locations queues get*](api::ProjectLocationQueueGetCall), [*locations queues get iam policy*](api::ProjectLocationQueueGetIamPolicyCall), [*locations queues list*](api::ProjectLocationQueueListCall), [*locations queues patch*](api::ProjectLocationQueuePatchCall), [*locations queues pause*](api::ProjectLocationQueuePauseCall), [*locations queues purge*](api::ProjectLocationQueuePurgeCall), [*locations queues resume*](api::ProjectLocationQueueResumeCall), [*locations queues set iam policy*](api::ProjectLocationQueueSetIamPolicyCall), [*locations queues tasks buffer*](api::ProjectLocationQueueTaskBufferCall), [*locations queues tasks create*](api::ProjectLocationQueueTaskCreateCall), [*locations queues tasks delete*](api::ProjectLocationQueueTaskDeleteCall), [*locations queues tasks get*](api::ProjectLocationQueueTaskGetCall), [*locations queues tasks list*](api::ProjectLocationQueueTaskListCall), [*locations queues tasks run*](api::ProjectLocationQueueTaskRunCall), [*locations queues test iam permissions*](api::ProjectLocationQueueTestIamPermissionCall) and [*locations update cmek config*](api::ProjectLocationUpdateCmekConfigCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_queues_resume(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use cloudtasks2::{CloudTasks, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudtasks2_beta2/src/lib.rs b/gen/cloudtasks2_beta2/src/lib.rs index 9bf4638c62..d7e82d8ecd 100644 --- a/gen/cloudtasks2_beta2/src/lib.rs +++ b/gen/cloudtasks2_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudtasks2_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudTasks) ... +//! Handle the following *Resources* with ease from the central [hub](CloudTasks) ... //! //! * api //! * [*queue update*](api::ApiQueueUpdateCall) @@ -57,8 +57,8 @@ //! let r = hub.projects().locations_queues_resume(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use cloudtasks2_beta2::{CloudTasks, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudtasks2_beta3/src/lib.rs b/gen/cloudtasks2_beta3/src/lib.rs index fb144599c9..5370e4ebfb 100644 --- a/gen/cloudtasks2_beta3/src/lib.rs +++ b/gen/cloudtasks2_beta3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudtasks2_beta3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudTasks) ... +//! Handle the following *Resources* with ease from the central [hub](CloudTasks) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations get cmek config*](api::ProjectLocationGetCmekConfigCall), [*locations list*](api::ProjectLocationListCall), [*locations queues create*](api::ProjectLocationQueueCreateCall), [*locations queues delete*](api::ProjectLocationQueueDeleteCall), [*locations queues get*](api::ProjectLocationQueueGetCall), [*locations queues get iam policy*](api::ProjectLocationQueueGetIamPolicyCall), [*locations queues list*](api::ProjectLocationQueueListCall), [*locations queues patch*](api::ProjectLocationQueuePatchCall), [*locations queues pause*](api::ProjectLocationQueuePauseCall), [*locations queues purge*](api::ProjectLocationQueuePurgeCall), [*locations queues resume*](api::ProjectLocationQueueResumeCall), [*locations queues set iam policy*](api::ProjectLocationQueueSetIamPolicyCall), [*locations queues tasks buffer*](api::ProjectLocationQueueTaskBufferCall), [*locations queues tasks create*](api::ProjectLocationQueueTaskCreateCall), [*locations queues tasks delete*](api::ProjectLocationQueueTaskDeleteCall), [*locations queues tasks get*](api::ProjectLocationQueueTaskGetCall), [*locations queues tasks list*](api::ProjectLocationQueueTaskListCall), [*locations queues tasks run*](api::ProjectLocationQueueTaskRunCall), [*locations queues test iam permissions*](api::ProjectLocationQueueTestIamPermissionCall) and [*locations update cmek config*](api::ProjectLocationUpdateCmekConfigCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_queues_resume(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use cloudtasks2_beta3::{CloudTasks, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudtrace1/src/lib.rs b/gen/cloudtrace1/src/lib.rs index 04e58ec5fc..6becbfbcbe 100644 --- a/gen/cloudtrace1/src/lib.rs +++ b/gen/cloudtrace1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudtrace1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudTrace) ... +//! Handle the following *Resources* with ease from the central [hub](CloudTrace) ... //! //! * projects //! * [*patch traces*](api::ProjectPatchTraceCall), [*traces get*](api::ProjectTraceGetCall) and [*traces list*](api::ProjectTraceListCall) @@ -50,8 +50,8 @@ //! let r = hub.projects().traces_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use cloudtrace1::{CloudTrace, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -120,10 +120,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -133,25 +133,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/cloudtrace2/src/lib.rs b/gen/cloudtrace2/src/lib.rs index 9e71c66cc0..262dcd236e 100644 --- a/gen/cloudtrace2/src/lib.rs +++ b/gen/cloudtrace2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/cloudtrace2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudTrace) ... +//! Handle the following *Resources* with ease from the central [hub](CloudTrace) ... //! //! * projects //! * [*traces batch write*](api::ProjectTraceBatchWriteCall) and [*traces spans create span*](api::ProjectTraceSpanCreateSpanCall) @@ -50,8 +50,8 @@ //! let r = hub.projects().traces_spans_create_span(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use cloudtrace2::{CloudTrace, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/clouduseraccountsvm_beta/src/lib.rs b/gen/clouduseraccountsvm_beta/src/lib.rs index 55474f719d..7dd39a0b0e 100644 --- a/gen/clouduseraccountsvm_beta/src/lib.rs +++ b/gen/clouduseraccountsvm_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/clouduseraccountsvm_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudUserAccounts) ... +//! Handle the following *Resources* with ease from the central [hub](CloudUserAccounts) ... //! //! * global accounts operations //! * [*delete*](api::GlobalAccountsOperationDeleteCall), [*get*](api::GlobalAccountsOperationGetCall) and [*list*](api::GlobalAccountsOperationListCall) @@ -64,8 +64,8 @@ //! let r = hub.users().remove_public_key(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -94,12 +94,12 @@ //! use std::default::Default; //! use clouduseraccountsvm_beta::{CloudUserAccounts, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -140,10 +140,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -153,25 +153,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/commentanalyzer1_alpha1/src/lib.rs b/gen/commentanalyzer1_alpha1/src/lib.rs index 2826bccaee..fe81a3c53e 100644 --- a/gen/commentanalyzer1_alpha1/src/lib.rs +++ b/gen/commentanalyzer1_alpha1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/commentanalyzer1_alpha1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CommentAnalyzer) ... +//! Handle the following *Resources* with ease from the central [hub](CommentAnalyzer) ... //! //! * comments //! * [*analyze*](api::CommentAnalyzeCall) and [*suggestscore*](api::CommentSuggestscoreCall) @@ -50,8 +50,8 @@ //! let r = hub.comments().analyze(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use commentanalyzer1_alpha1::{CommentAnalyzer, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/composer1/src/lib.rs b/gen/composer1/src/lib.rs index ff84a838a8..591d5101f3 100644 --- a/gen/composer1/src/lib.rs +++ b/gen/composer1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/composer1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudComposer) ... +//! Handle the following *Resources* with ease from the central [hub](CloudComposer) ... //! //! * projects //! * [*locations environments create*](api::ProjectLocationEnvironmentCreateCall), [*locations environments database failover*](api::ProjectLocationEnvironmentDatabaseFailoverCall), [*locations environments delete*](api::ProjectLocationEnvironmentDeleteCall), [*locations environments execute airflow command*](api::ProjectLocationEnvironmentExecuteAirflowCommandCall), [*locations environments fetch database properties*](api::ProjectLocationEnvironmentFetchDatabasePropertyCall), [*locations environments get*](api::ProjectLocationEnvironmentGetCall), [*locations environments list*](api::ProjectLocationEnvironmentListCall), [*locations environments load snapshot*](api::ProjectLocationEnvironmentLoadSnapshotCall), [*locations environments patch*](api::ProjectLocationEnvironmentPatchCall), [*locations environments poll airflow command*](api::ProjectLocationEnvironmentPollAirflowCommandCall), [*locations environments save snapshot*](api::ProjectLocationEnvironmentSaveSnapshotCall), [*locations environments stop airflow command*](api::ProjectLocationEnvironmentStopAirflowCommandCall), [*locations environments user workloads config maps create*](api::ProjectLocationEnvironmentUserWorkloadsConfigMapCreateCall), [*locations environments user workloads config maps delete*](api::ProjectLocationEnvironmentUserWorkloadsConfigMapDeleteCall), [*locations environments user workloads config maps get*](api::ProjectLocationEnvironmentUserWorkloadsConfigMapGetCall), [*locations environments user workloads config maps list*](api::ProjectLocationEnvironmentUserWorkloadsConfigMapListCall), [*locations environments user workloads config maps update*](api::ProjectLocationEnvironmentUserWorkloadsConfigMapUpdateCall), [*locations environments user workloads secrets create*](api::ProjectLocationEnvironmentUserWorkloadsSecretCreateCall), [*locations environments user workloads secrets delete*](api::ProjectLocationEnvironmentUserWorkloadsSecretDeleteCall), [*locations environments user workloads secrets get*](api::ProjectLocationEnvironmentUserWorkloadsSecretGetCall), [*locations environments user workloads secrets list*](api::ProjectLocationEnvironmentUserWorkloadsSecretListCall), [*locations environments user workloads secrets update*](api::ProjectLocationEnvironmentUserWorkloadsSecretUpdateCall), [*locations environments workloads list*](api::ProjectLocationEnvironmentWorkloadListCall), [*locations image versions list*](api::ProjectLocationImageVersionListCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -56,8 +56,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use composer1::{CloudComposer, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/compute1/src/lib.rs b/gen/compute1/src/lib.rs index 1bc28d92c0..db5de544cb 100644 --- a/gen/compute1/src/lib.rs +++ b/gen/compute1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/compute1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Compute) ... +//! Handle the following *Resources* with ease from the central [hub](Compute) ... //! //! * [accelerator types](api::AcceleratorType) //! * [*aggregated list*](api::AcceleratorTypeAggregatedListCall), [*get*](api::AcceleratorTypeGetCall) and [*list*](api::AcceleratorTypeListCall) @@ -644,8 +644,8 @@ //! let r = hub.zone_operations().wait(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -674,12 +674,12 @@ //! use std::default::Default; //! use compute1::{Compute, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -723,10 +723,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -736,25 +736,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/connectors1/src/lib.rs b/gen/connectors1/src/lib.rs index fe550e7bfc..c5104203cf 100644 --- a/gen/connectors1/src/lib.rs +++ b/gen/connectors1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/connectors1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Connectors) ... +//! Handle the following *Resources* with ease from the central [hub](Connectors) ... //! //! * projects //! * [*locations connections connection schema metadata get action*](api::ProjectLocationConnectionConnectionSchemaMetadataGetActionCall), [*locations connections connection schema metadata get entity type*](api::ProjectLocationConnectionConnectionSchemaMetadataGetEntityTypeCall), [*locations connections connection schema metadata list actions*](api::ProjectLocationConnectionConnectionSchemaMetadataListActionCall), [*locations connections connection schema metadata list entity types*](api::ProjectLocationConnectionConnectionSchemaMetadataListEntityTypeCall), [*locations connections connection schema metadata refresh*](api::ProjectLocationConnectionConnectionSchemaMetadataRefreshCall), [*locations connections create*](api::ProjectLocationConnectionCreateCall), [*locations connections delete*](api::ProjectLocationConnectionDeleteCall), [*locations connections event subscriptions create*](api::ProjectLocationConnectionEventSubscriptionCreateCall), [*locations connections event subscriptions delete*](api::ProjectLocationConnectionEventSubscriptionDeleteCall), [*locations connections event subscriptions get*](api::ProjectLocationConnectionEventSubscriptionGetCall), [*locations connections event subscriptions list*](api::ProjectLocationConnectionEventSubscriptionListCall), [*locations connections event subscriptions patch*](api::ProjectLocationConnectionEventSubscriptionPatchCall), [*locations connections event subscriptions retry*](api::ProjectLocationConnectionEventSubscriptionRetryCall), [*locations connections get*](api::ProjectLocationConnectionGetCall), [*locations connections get connection schema metadata*](api::ProjectLocationConnectionGetConnectionSchemaMetadataCall), [*locations connections get iam policy*](api::ProjectLocationConnectionGetIamPolicyCall), [*locations connections list*](api::ProjectLocationConnectionListCall), [*locations connections listen event*](api::ProjectLocationConnectionListenEventCall), [*locations connections patch*](api::ProjectLocationConnectionPatchCall), [*locations connections repair eventing*](api::ProjectLocationConnectionRepairEventingCall), [*locations connections runtime action schemas list*](api::ProjectLocationConnectionRuntimeActionSchemaListCall), [*locations connections runtime entity schemas list*](api::ProjectLocationConnectionRuntimeEntitySchemaListCall), [*locations connections set iam policy*](api::ProjectLocationConnectionSetIamPolicyCall), [*locations connections test iam permissions*](api::ProjectLocationConnectionTestIamPermissionCall), [*locations endpoint attachments create*](api::ProjectLocationEndpointAttachmentCreateCall), [*locations endpoint attachments delete*](api::ProjectLocationEndpointAttachmentDeleteCall), [*locations endpoint attachments get*](api::ProjectLocationEndpointAttachmentGetCall), [*locations endpoint attachments list*](api::ProjectLocationEndpointAttachmentListCall), [*locations endpoint attachments patch*](api::ProjectLocationEndpointAttachmentPatchCall), [*locations get*](api::ProjectLocationGetCall), [*locations get regional settings*](api::ProjectLocationGetRegionalSettingCall), [*locations get runtime config*](api::ProjectLocationGetRuntimeConfigCall), [*locations global custom connectors create*](api::ProjectLocationGlobalCustomConnectorCreateCall), [*locations global custom connectors custom connector versions create*](api::ProjectLocationGlobalCustomConnectorCustomConnectorVersionCreateCall), [*locations global custom connectors custom connector versions delete*](api::ProjectLocationGlobalCustomConnectorCustomConnectorVersionDeleteCall), [*locations global custom connectors custom connector versions get*](api::ProjectLocationGlobalCustomConnectorCustomConnectorVersionGetCall), [*locations global custom connectors custom connector versions list*](api::ProjectLocationGlobalCustomConnectorCustomConnectorVersionListCall), [*locations global custom connectors custom connector versions patch*](api::ProjectLocationGlobalCustomConnectorCustomConnectorVersionPatchCall), [*locations global custom connectors delete*](api::ProjectLocationGlobalCustomConnectorDeleteCall), [*locations global custom connectors get*](api::ProjectLocationGlobalCustomConnectorGetCall), [*locations global custom connectors list*](api::ProjectLocationGlobalCustomConnectorListCall), [*locations global custom connectors patch*](api::ProjectLocationGlobalCustomConnectorPatchCall), [*locations global get settings*](api::ProjectLocationGlobalGetSettingCall), [*locations global managed zones create*](api::ProjectLocationGlobalManagedZoneCreateCall), [*locations global managed zones delete*](api::ProjectLocationGlobalManagedZoneDeleteCall), [*locations global managed zones get*](api::ProjectLocationGlobalManagedZoneGetCall), [*locations global managed zones list*](api::ProjectLocationGlobalManagedZoneListCall), [*locations global managed zones patch*](api::ProjectLocationGlobalManagedZonePatchCall), [*locations global update settings*](api::ProjectLocationGlobalUpdateSettingCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations providers connectors get*](api::ProjectLocationProviderConnectorGetCall), [*locations providers connectors list*](api::ProjectLocationProviderConnectorListCall), [*locations providers connectors versions eventtypes get*](api::ProjectLocationProviderConnectorVersionEventtypeGetCall), [*locations providers connectors versions eventtypes list*](api::ProjectLocationProviderConnectorVersionEventtypeListCall), [*locations providers connectors versions get*](api::ProjectLocationProviderConnectorVersionGetCall), [*locations providers connectors versions list*](api::ProjectLocationProviderConnectorVersionListCall), [*locations providers get*](api::ProjectLocationProviderGetCall), [*locations providers get iam policy*](api::ProjectLocationProviderGetIamPolicyCall), [*locations providers list*](api::ProjectLocationProviderListCall), [*locations providers set iam policy*](api::ProjectLocationProviderSetIamPolicyCall), [*locations providers test iam permissions*](api::ProjectLocationProviderTestIamPermissionCall) and [*locations update regional settings*](api::ProjectLocationUpdateRegionalSettingCall) @@ -75,8 +75,8 @@ //! let r = hub.projects().locations_update_regional_settings(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -105,12 +105,12 @@ //! use std::default::Default; //! use connectors1::{Connectors, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -152,10 +152,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -165,25 +165,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/consumersurveys2/src/lib.rs b/gen/consumersurveys2/src/lib.rs index d4f5bf7ed1..6e2cfd5e2e 100644 --- a/gen/consumersurveys2/src/lib.rs +++ b/gen/consumersurveys2/src/lib.rs @@ -6,7 +6,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/consumersurveys2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ConsumerSurveys) ... +//! Handle the following *Resources* with ease from the central [hub](ConsumerSurveys) ... //! //! * mobileapppanels //! * [*get*](api::MobileapppanelGetCall), [*list*](api::MobileapppanelListCall) and [*update*](api::MobileapppanelUpdateCall) @@ -61,8 +61,8 @@ //! let r = hub.surveys().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use consumersurveys2::{ConsumerSurveys, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/contactcenterinsights1/src/lib.rs b/gen/contactcenterinsights1/src/lib.rs index ca07044af4..a04a01b99e 100644 --- a/gen/contactcenterinsights1/src/lib.rs +++ b/gen/contactcenterinsights1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/contactcenterinsights1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Contactcenterinsights) ... +//! Handle the following *Resources* with ease from the central [hub](Contactcenterinsights) ... //! //! * projects //! * [*locations conversations analyses create*](api::ProjectLocationConversationAnalysisCreateCall), [*locations conversations analyses delete*](api::ProjectLocationConversationAnalysisDeleteCall), [*locations conversations analyses get*](api::ProjectLocationConversationAnalysisGetCall), [*locations conversations analyses list*](api::ProjectLocationConversationAnalysisListCall), [*locations conversations bulk analyze*](api::ProjectLocationConversationBulkAnalyzeCall), [*locations conversations bulk delete*](api::ProjectLocationConversationBulkDeleteCall), [*locations conversations calculate stats*](api::ProjectLocationConversationCalculateStatCall), [*locations conversations create*](api::ProjectLocationConversationCreateCall), [*locations conversations delete*](api::ProjectLocationConversationDeleteCall), [*locations conversations get*](api::ProjectLocationConversationGetCall), [*locations conversations ingest*](api::ProjectLocationConversationIngestCall), [*locations conversations list*](api::ProjectLocationConversationListCall), [*locations conversations patch*](api::ProjectLocationConversationPatchCall), [*locations conversations upload*](api::ProjectLocationConversationUploadCall), [*locations get settings*](api::ProjectLocationGetSettingCall), [*locations insightsdata export*](api::ProjectLocationInsightsdataExportCall), [*locations issue models calculate issue model stats*](api::ProjectLocationIssueModelCalculateIssueModelStatCall), [*locations issue models create*](api::ProjectLocationIssueModelCreateCall), [*locations issue models delete*](api::ProjectLocationIssueModelDeleteCall), [*locations issue models deploy*](api::ProjectLocationIssueModelDeployCall), [*locations issue models export*](api::ProjectLocationIssueModelExportCall), [*locations issue models get*](api::ProjectLocationIssueModelGetCall), [*locations issue models import*](api::ProjectLocationIssueModelImportCall), [*locations issue models issues delete*](api::ProjectLocationIssueModelIssueDeleteCall), [*locations issue models issues get*](api::ProjectLocationIssueModelIssueGetCall), [*locations issue models issues list*](api::ProjectLocationIssueModelIssueListCall), [*locations issue models issues patch*](api::ProjectLocationIssueModelIssuePatchCall), [*locations issue models list*](api::ProjectLocationIssueModelListCall), [*locations issue models patch*](api::ProjectLocationIssueModelPatchCall), [*locations issue models undeploy*](api::ProjectLocationIssueModelUndeployCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations phrase matchers create*](api::ProjectLocationPhraseMatcherCreateCall), [*locations phrase matchers delete*](api::ProjectLocationPhraseMatcherDeleteCall), [*locations phrase matchers get*](api::ProjectLocationPhraseMatcherGetCall), [*locations phrase matchers list*](api::ProjectLocationPhraseMatcherListCall), [*locations phrase matchers patch*](api::ProjectLocationPhraseMatcherPatchCall), [*locations update settings*](api::ProjectLocationUpdateSettingCall), [*locations views create*](api::ProjectLocationViewCreateCall), [*locations views delete*](api::ProjectLocationViewDeleteCall), [*locations views get*](api::ProjectLocationViewGetCall), [*locations views list*](api::ProjectLocationViewListCall) and [*locations views patch*](api::ProjectLocationViewPatchCall) @@ -62,8 +62,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use contactcenterinsights1::{Contactcenterinsights, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -138,10 +138,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -151,25 +151,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/container1/src/lib.rs b/gen/container1/src/lib.rs index 4de7f1b6fa..1e0237ba5b 100644 --- a/gen/container1/src/lib.rs +++ b/gen/container1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/container1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Container) ... +//! Handle the following *Resources* with ease from the central [hub](Container) ... //! //! * projects //! * [*aggregated usable subnetworks list*](api::ProjectAggregatedUsableSubnetworkListCall), [*locations clusters check autopilot compatibility*](api::ProjectLocationClusterCheckAutopilotCompatibilityCall), [*locations clusters complete ip rotation*](api::ProjectLocationClusterCompleteIpRotationCall), [*locations clusters create*](api::ProjectLocationClusterCreateCall), [*locations clusters delete*](api::ProjectLocationClusterDeleteCall), [*locations clusters get*](api::ProjectLocationClusterGetCall), [*locations clusters get jwks*](api::ProjectLocationClusterGetJwkCall), [*locations clusters list*](api::ProjectLocationClusterListCall), [*locations clusters node pools complete upgrade*](api::ProjectLocationClusterNodePoolCompleteUpgradeCall), [*locations clusters node pools create*](api::ProjectLocationClusterNodePoolCreateCall), [*locations clusters node pools delete*](api::ProjectLocationClusterNodePoolDeleteCall), [*locations clusters node pools get*](api::ProjectLocationClusterNodePoolGetCall), [*locations clusters node pools list*](api::ProjectLocationClusterNodePoolListCall), [*locations clusters node pools rollback*](api::ProjectLocationClusterNodePoolRollbackCall), [*locations clusters node pools set autoscaling*](api::ProjectLocationClusterNodePoolSetAutoscalingCall), [*locations clusters node pools set management*](api::ProjectLocationClusterNodePoolSetManagementCall), [*locations clusters node pools set size*](api::ProjectLocationClusterNodePoolSetSizeCall), [*locations clusters node pools update*](api::ProjectLocationClusterNodePoolUpdateCall), [*locations clusters set addons*](api::ProjectLocationClusterSetAddonCall), [*locations clusters set legacy abac*](api::ProjectLocationClusterSetLegacyAbacCall), [*locations clusters set locations*](api::ProjectLocationClusterSetLocationCall), [*locations clusters set logging*](api::ProjectLocationClusterSetLoggingCall), [*locations clusters set maintenance policy*](api::ProjectLocationClusterSetMaintenancePolicyCall), [*locations clusters set master auth*](api::ProjectLocationClusterSetMasterAuthCall), [*locations clusters set monitoring*](api::ProjectLocationClusterSetMonitoringCall), [*locations clusters set network policy*](api::ProjectLocationClusterSetNetworkPolicyCall), [*locations clusters set resource labels*](api::ProjectLocationClusterSetResourceLabelCall), [*locations clusters start ip rotation*](api::ProjectLocationClusterStartIpRotationCall), [*locations clusters update*](api::ProjectLocationClusterUpdateCall), [*locations clusters update master*](api::ProjectLocationClusterUpdateMasterCall), [*locations clusters well-known get openid-configuration*](api::ProjectLocationClusterWellKnownGetOpenidConfigurationCall), [*locations get server config*](api::ProjectLocationGetServerConfigCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*zones clusters addons*](api::ProjectZoneClusterAddonCall), [*zones clusters complete ip rotation*](api::ProjectZoneClusterCompleteIpRotationCall), [*zones clusters create*](api::ProjectZoneClusterCreateCall), [*zones clusters delete*](api::ProjectZoneClusterDeleteCall), [*zones clusters get*](api::ProjectZoneClusterGetCall), [*zones clusters legacy abac*](api::ProjectZoneClusterLegacyAbacCall), [*zones clusters list*](api::ProjectZoneClusterListCall), [*zones clusters locations*](api::ProjectZoneClusterLocationCall), [*zones clusters logging*](api::ProjectZoneClusterLoggingCall), [*zones clusters master*](api::ProjectZoneClusterMasterCall), [*zones clusters monitoring*](api::ProjectZoneClusterMonitoringCall), [*zones clusters node pools autoscaling*](api::ProjectZoneClusterNodePoolAutoscalingCall), [*zones clusters node pools create*](api::ProjectZoneClusterNodePoolCreateCall), [*zones clusters node pools delete*](api::ProjectZoneClusterNodePoolDeleteCall), [*zones clusters node pools get*](api::ProjectZoneClusterNodePoolGetCall), [*zones clusters node pools list*](api::ProjectZoneClusterNodePoolListCall), [*zones clusters node pools rollback*](api::ProjectZoneClusterNodePoolRollbackCall), [*zones clusters node pools set management*](api::ProjectZoneClusterNodePoolSetManagementCall), [*zones clusters node pools set size*](api::ProjectZoneClusterNodePoolSetSizeCall), [*zones clusters node pools update*](api::ProjectZoneClusterNodePoolUpdateCall), [*zones clusters resource labels*](api::ProjectZoneClusterResourceLabelCall), [*zones clusters set maintenance policy*](api::ProjectZoneClusterSetMaintenancePolicyCall), [*zones clusters set master auth*](api::ProjectZoneClusterSetMasterAuthCall), [*zones clusters set network policy*](api::ProjectZoneClusterSetNetworkPolicyCall), [*zones clusters start ip rotation*](api::ProjectZoneClusterStartIpRotationCall), [*zones clusters update*](api::ProjectZoneClusterUpdateCall), [*zones get serverconfig*](api::ProjectZoneGetServerconfigCall), [*zones operations cancel*](api::ProjectZoneOperationCancelCall), [*zones operations get*](api::ProjectZoneOperationGetCall) and [*zones operations list*](api::ProjectZoneOperationListCall) @@ -95,8 +95,8 @@ //! let r = hub.projects().zones_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -124,12 +124,12 @@ //! use std::default::Default; //! use container1::{Container, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -169,10 +169,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -182,25 +182,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/containeranalysis1/src/lib.rs b/gen/containeranalysis1/src/lib.rs index 46593ee71f..2dd238e069 100644 --- a/gen/containeranalysis1/src/lib.rs +++ b/gen/containeranalysis1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/containeranalysis1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ContainerAnalysis) ... +//! Handle the following *Resources* with ease from the central [hub](ContainerAnalysis) ... //! //! * projects //! * [*notes batch create*](api::ProjectNoteBatchCreateCall), [*notes create*](api::ProjectNoteCreateCall), [*notes delete*](api::ProjectNoteDeleteCall), [*notes get*](api::ProjectNoteGetCall), [*notes get iam policy*](api::ProjectNoteGetIamPolicyCall), [*notes list*](api::ProjectNoteListCall), [*notes occurrences list*](api::ProjectNoteOccurrenceListCall), [*notes patch*](api::ProjectNotePatchCall), [*notes set iam policy*](api::ProjectNoteSetIamPolicyCall), [*notes test iam permissions*](api::ProjectNoteTestIamPermissionCall), [*occurrences batch create*](api::ProjectOccurrenceBatchCreateCall), [*occurrences create*](api::ProjectOccurrenceCreateCall), [*occurrences delete*](api::ProjectOccurrenceDeleteCall), [*occurrences get*](api::ProjectOccurrenceGetCall), [*occurrences get iam policy*](api::ProjectOccurrenceGetIamPolicyCall), [*occurrences get notes*](api::ProjectOccurrenceGetNoteCall), [*occurrences get vulnerability summary*](api::ProjectOccurrenceGetVulnerabilitySummaryCall), [*occurrences list*](api::ProjectOccurrenceListCall), [*occurrences patch*](api::ProjectOccurrencePatchCall), [*occurrences set iam policy*](api::ProjectOccurrenceSetIamPolicyCall), [*occurrences test iam permissions*](api::ProjectOccurrenceTestIamPermissionCall) and [*resources export sbom*](api::ProjectResourceExportSBOMCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().occurrences_get_notes(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use containeranalysis1::{ContainerAnalysis, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/containeranalysis1_beta1/src/lib.rs b/gen/containeranalysis1_beta1/src/lib.rs index 3ac7337282..c93dee76ae 100644 --- a/gen/containeranalysis1_beta1/src/lib.rs +++ b/gen/containeranalysis1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/containeranalysis1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ContainerAnalysis) ... +//! Handle the following *Resources* with ease from the central [hub](ContainerAnalysis) ... //! //! * projects //! * [*notes batch create*](api::ProjectNoteBatchCreateCall), [*notes create*](api::ProjectNoteCreateCall), [*notes delete*](api::ProjectNoteDeleteCall), [*notes get*](api::ProjectNoteGetCall), [*notes get iam policy*](api::ProjectNoteGetIamPolicyCall), [*notes list*](api::ProjectNoteListCall), [*notes occurrences list*](api::ProjectNoteOccurrenceListCall), [*notes patch*](api::ProjectNotePatchCall), [*notes set iam policy*](api::ProjectNoteSetIamPolicyCall), [*notes test iam permissions*](api::ProjectNoteTestIamPermissionCall), [*occurrences batch create*](api::ProjectOccurrenceBatchCreateCall), [*occurrences create*](api::ProjectOccurrenceCreateCall), [*occurrences delete*](api::ProjectOccurrenceDeleteCall), [*occurrences get*](api::ProjectOccurrenceGetCall), [*occurrences get iam policy*](api::ProjectOccurrenceGetIamPolicyCall), [*occurrences get notes*](api::ProjectOccurrenceGetNoteCall), [*occurrences get vulnerability summary*](api::ProjectOccurrenceGetVulnerabilitySummaryCall), [*occurrences list*](api::ProjectOccurrenceListCall), [*occurrences patch*](api::ProjectOccurrencePatchCall), [*occurrences set iam policy*](api::ProjectOccurrenceSetIamPolicyCall), [*occurrences test iam permissions*](api::ProjectOccurrenceTestIamPermissionCall), [*resources export sbom*](api::ProjectResourceExportSBOMCall) and [*resources generate packages summary*](api::ProjectResourceGeneratePackagesSummaryCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().occurrences_get_notes(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use containeranalysis1_beta1::{ContainerAnalysis, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/content2/src/lib.rs b/gen/content2/src/lib.rs index e565766364..1108e63205 100644 --- a/gen/content2/src/lib.rs +++ b/gen/content2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/content2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ShoppingContent) ... +//! Handle the following *Resources* with ease from the central [hub](ShoppingContent) ... //! //! * [accounts](api::Account) //! * [*authinfo*](api::AccountAuthinfoCall), [*claimwebsite*](api::AccountClaimwebsiteCall), [*custombatch*](api::AccountCustombatchCall), [*delete*](api::AccountDeleteCall), [*get*](api::AccountGetCall), [*insert*](api::AccountInsertCall), [*link*](api::AccountLinkCall), [*list*](api::AccountListCall) and [*update*](api::AccountUpdateCall) @@ -99,8 +99,8 @@ //! let r = hub.orders().updateshipment(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -128,12 +128,12 @@ //! use std::default::Default; //! use content2::{ShoppingContent, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -176,10 +176,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -189,25 +189,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/content2_sandbox/src/lib.rs b/gen/content2_sandbox/src/lib.rs index 38d68734e3..fc0e5d0d32 100644 --- a/gen/content2_sandbox/src/lib.rs +++ b/gen/content2_sandbox/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/content2_sandbox). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ShoppingContent) ... +//! Handle the following *Resources* with ease from the central [hub](ShoppingContent) ... //! //! * orderinvoices //! * [*createchargeinvoice*](api::OrderinvoiceCreatechargeinvoiceCall) and [*createrefundinvoice*](api::OrderinvoiceCreaterefundinvoiceCall) @@ -77,8 +77,8 @@ //! let r = hub.orders().updateshipment(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -106,12 +106,12 @@ //! use std::default::Default; //! use content2_sandbox::{ShoppingContent, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -154,10 +154,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -167,25 +167,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/coordinate1/src/lib.rs b/gen/coordinate1/src/lib.rs index 1518cf2fae..1f28c15195 100644 --- a/gen/coordinate1/src/lib.rs +++ b/gen/coordinate1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/coordinate1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Coordinate) ... +//! Handle the following *Resources* with ease from the central [hub](Coordinate) ... //! //! * [custom field def](api::CustomFieldDef) //! * [*list*](api::CustomFieldDefListCall) @@ -64,8 +64,8 @@ //! let r = hub.jobs().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -94,12 +94,12 @@ //! use std::default::Default; //! use coordinate1::{Coordinate, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -150,10 +150,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -163,25 +163,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/customsearch1/src/api.rs b/gen/customsearch1/src/api.rs index 81e103726c..1098cb5dfd 100644 --- a/gen/customsearch1/src/api.rs +++ b/gen/customsearch1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use customsearch1::{CustomSearchAPI, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/customsearch1/src/lib.rs b/gen/customsearch1/src/lib.rs index 1cc58ae02c..a23dd43c4a 100644 --- a/gen/customsearch1/src/lib.rs +++ b/gen/customsearch1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/customsearch1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CustomSearchAPI) ... +//! Handle the following *Resources* with ease from the central [hub](CustomSearchAPI) ... //! //! * cse //! * [*list*](api::CseListCall) and [*siterestrict list*](api::CseSiterestrictListCall) @@ -51,8 +51,8 @@ //! let r = hub.cse().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use customsearch1::{CustomSearchAPI, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -152,10 +152,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -165,25 +165,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datacatalog1/src/lib.rs b/gen/datacatalog1/src/lib.rs index 9f37dc3516..de29446def 100644 --- a/gen/datacatalog1/src/lib.rs +++ b/gen/datacatalog1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datacatalog1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DataCatalog) ... +//! Handle the following *Resources* with ease from the central [hub](DataCatalog) ... //! //! * catalog //! * [*search*](api::CatalogSearchCall) @@ -63,8 +63,8 @@ //! let r = hub.projects().locations_taxonomies_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use datacatalog1::{DataCatalog, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datacatalog1_beta1/src/lib.rs b/gen/datacatalog1_beta1/src/lib.rs index 0fc9ed276a..0c8cf1b6bd 100644 --- a/gen/datacatalog1_beta1/src/lib.rs +++ b/gen/datacatalog1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datacatalog1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DataCatalog) ... +//! Handle the following *Resources* with ease from the central [hub](DataCatalog) ... //! //! * catalog //! * [*search*](api::CatalogSearchCall) @@ -62,8 +62,8 @@ //! let r = hub.projects().locations_taxonomies_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use datacatalog1_beta1::{DataCatalog, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -138,10 +138,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -151,25 +151,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datafusion1/src/lib.rs b/gen/datafusion1/src/lib.rs index aa7f1e59ca..d1ac3619c3 100644 --- a/gen/datafusion1/src/lib.rs +++ b/gen/datafusion1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datafusion1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DataFusion) ... +//! Handle the following *Resources* with ease from the central [hub](DataFusion) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances dns peerings create*](api::ProjectLocationInstanceDnsPeeringCreateCall), [*locations instances dns peerings delete*](api::ProjectLocationInstanceDnsPeeringDeleteCall), [*locations instances dns peerings list*](api::ProjectLocationInstanceDnsPeeringListCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances get iam policy*](api::ProjectLocationInstanceGetIamPolicyCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances patch*](api::ProjectLocationInstancePatchCall), [*locations instances restart*](api::ProjectLocationInstanceRestartCall), [*locations instances set iam policy*](api::ProjectLocationInstanceSetIamPolicyCall), [*locations instances test iam permissions*](api::ProjectLocationInstanceTestIamPermissionCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall) and [*locations versions list*](api::ProjectLocationVersionListCall) @@ -54,8 +54,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use datafusion1::{DataFusion, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datafusion1_beta1/src/lib.rs b/gen/datafusion1_beta1/src/lib.rs index 90155e3e15..c04f3ee506 100644 --- a/gen/datafusion1_beta1/src/lib.rs +++ b/gen/datafusion1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datafusion1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DataFusion) ... +//! Handle the following *Resources* with ease from the central [hub](DataFusion) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances dns peerings create*](api::ProjectLocationInstanceDnsPeeringCreateCall), [*locations instances dns peerings delete*](api::ProjectLocationInstanceDnsPeeringDeleteCall), [*locations instances dns peerings list*](api::ProjectLocationInstanceDnsPeeringListCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances get iam policy*](api::ProjectLocationInstanceGetIamPolicyCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances namespaces get iam policy*](api::ProjectLocationInstanceNamespaceGetIamPolicyCall), [*locations instances namespaces list*](api::ProjectLocationInstanceNamespaceListCall), [*locations instances namespaces set iam policy*](api::ProjectLocationInstanceNamespaceSetIamPolicyCall), [*locations instances namespaces test iam permissions*](api::ProjectLocationInstanceNamespaceTestIamPermissionCall), [*locations instances patch*](api::ProjectLocationInstancePatchCall), [*locations instances restart*](api::ProjectLocationInstanceRestartCall), [*locations instances set iam policy*](api::ProjectLocationInstanceSetIamPolicyCall), [*locations instances test iam permissions*](api::ProjectLocationInstanceTestIamPermissionCall), [*locations instances upgrade*](api::ProjectLocationInstanceUpgradeCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations remove iam policy*](api::ProjectLocationRemoveIamPolicyCall) and [*locations versions list*](api::ProjectLocationVersionListCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use datafusion1_beta1::{DataFusion, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datalabeling1_beta1/src/lib.rs b/gen/datalabeling1_beta1/src/lib.rs index 064d2f4227..251661c81a 100644 --- a/gen/datalabeling1_beta1/src/lib.rs +++ b/gen/datalabeling1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datalabeling1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DataLabeling) ... +//! Handle the following *Resources* with ease from the central [hub](DataLabeling) ... //! //! * projects //! * [*annotation spec sets create*](api::ProjectAnnotationSpecSetCreateCall), [*annotation spec sets delete*](api::ProjectAnnotationSpecSetDeleteCall), [*annotation spec sets get*](api::ProjectAnnotationSpecSetGetCall), [*annotation spec sets list*](api::ProjectAnnotationSpecSetListCall), [*datasets annotated datasets data items get*](api::ProjectDatasetAnnotatedDatasetDataItemGetCall), [*datasets annotated datasets data items list*](api::ProjectDatasetAnnotatedDatasetDataItemListCall), [*datasets annotated datasets delete*](api::ProjectDatasetAnnotatedDatasetDeleteCall), [*datasets annotated datasets examples get*](api::ProjectDatasetAnnotatedDatasetExampleGetCall), [*datasets annotated datasets examples list*](api::ProjectDatasetAnnotatedDatasetExampleListCall), [*datasets annotated datasets feedback threads delete*](api::ProjectDatasetAnnotatedDatasetFeedbackThreadDeleteCall), [*datasets annotated datasets feedback threads feedback messages create*](api::ProjectDatasetAnnotatedDatasetFeedbackThreadFeedbackMessageCreateCall), [*datasets annotated datasets feedback threads feedback messages delete*](api::ProjectDatasetAnnotatedDatasetFeedbackThreadFeedbackMessageDeleteCall), [*datasets annotated datasets feedback threads feedback messages get*](api::ProjectDatasetAnnotatedDatasetFeedbackThreadFeedbackMessageGetCall), [*datasets annotated datasets feedback threads feedback messages list*](api::ProjectDatasetAnnotatedDatasetFeedbackThreadFeedbackMessageListCall), [*datasets annotated datasets feedback threads get*](api::ProjectDatasetAnnotatedDatasetFeedbackThreadGetCall), [*datasets annotated datasets feedback threads list*](api::ProjectDatasetAnnotatedDatasetFeedbackThreadListCall), [*datasets annotated datasets get*](api::ProjectDatasetAnnotatedDatasetGetCall), [*datasets annotated datasets list*](api::ProjectDatasetAnnotatedDatasetListCall), [*datasets create*](api::ProjectDatasetCreateCall), [*datasets data items get*](api::ProjectDatasetDataItemGetCall), [*datasets data items list*](api::ProjectDatasetDataItemListCall), [*datasets delete*](api::ProjectDatasetDeleteCall), [*datasets evaluations example comparisons search*](api::ProjectDatasetEvaluationExampleComparisonSearchCall), [*datasets evaluations get*](api::ProjectDatasetEvaluationGetCall), [*datasets export data*](api::ProjectDatasetExportDataCall), [*datasets get*](api::ProjectDatasetGetCall), [*datasets image label*](api::ProjectDatasetImageLabelCall), [*datasets import data*](api::ProjectDatasetImportDataCall), [*datasets list*](api::ProjectDatasetListCall), [*datasets text label*](api::ProjectDatasetTextLabelCall), [*datasets video label*](api::ProjectDatasetVideoLabelCall), [*evaluation jobs create*](api::ProjectEvaluationJobCreateCall), [*evaluation jobs delete*](api::ProjectEvaluationJobDeleteCall), [*evaluation jobs get*](api::ProjectEvaluationJobGetCall), [*evaluation jobs list*](api::ProjectEvaluationJobListCall), [*evaluation jobs patch*](api::ProjectEvaluationJobPatchCall), [*evaluation jobs pause*](api::ProjectEvaluationJobPauseCall), [*evaluation jobs resume*](api::ProjectEvaluationJobResumeCall), [*evaluations search*](api::ProjectEvaluationSearchCall), [*instructions create*](api::ProjectInstructionCreateCall), [*instructions delete*](api::ProjectInstructionDeleteCall), [*instructions get*](api::ProjectInstructionGetCall), [*instructions list*](api::ProjectInstructionListCall), [*operations cancel*](api::ProjectOperationCancelCall), [*operations delete*](api::ProjectOperationDeleteCall), [*operations get*](api::ProjectOperationGetCall) and [*operations list*](api::ProjectOperationListCall) @@ -60,8 +60,8 @@ //! let r = hub.projects().operations_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use datalabeling1_beta1::{DataLabeling, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datamigration1/src/lib.rs b/gen/datamigration1/src/lib.rs index f9cac0bf81..719f9f2b83 100644 --- a/gen/datamigration1/src/lib.rs +++ b/gen/datamigration1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datamigration1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DatabaseMigrationService) ... +//! Handle the following *Resources* with ease from the central [hub](DatabaseMigrationService) ... //! //! * projects //! * [*locations connection profiles create*](api::ProjectLocationConnectionProfileCreateCall), [*locations connection profiles delete*](api::ProjectLocationConnectionProfileDeleteCall), [*locations connection profiles get*](api::ProjectLocationConnectionProfileGetCall), [*locations connection profiles get iam policy*](api::ProjectLocationConnectionProfileGetIamPolicyCall), [*locations connection profiles list*](api::ProjectLocationConnectionProfileListCall), [*locations connection profiles patch*](api::ProjectLocationConnectionProfilePatchCall), [*locations connection profiles set iam policy*](api::ProjectLocationConnectionProfileSetIamPolicyCall), [*locations connection profiles test iam permissions*](api::ProjectLocationConnectionProfileTestIamPermissionCall), [*locations conversion workspaces apply*](api::ProjectLocationConversionWorkspaceApplyCall), [*locations conversion workspaces commit*](api::ProjectLocationConversionWorkspaceCommitCall), [*locations conversion workspaces convert*](api::ProjectLocationConversionWorkspaceConvertCall), [*locations conversion workspaces create*](api::ProjectLocationConversionWorkspaceCreateCall), [*locations conversion workspaces delete*](api::ProjectLocationConversionWorkspaceDeleteCall), [*locations conversion workspaces describe conversion workspace revisions*](api::ProjectLocationConversionWorkspaceDescribeConversionWorkspaceRevisionCall), [*locations conversion workspaces describe database entities*](api::ProjectLocationConversionWorkspaceDescribeDatabaseEntityCall), [*locations conversion workspaces get*](api::ProjectLocationConversionWorkspaceGetCall), [*locations conversion workspaces get iam policy*](api::ProjectLocationConversionWorkspaceGetIamPolicyCall), [*locations conversion workspaces list*](api::ProjectLocationConversionWorkspaceListCall), [*locations conversion workspaces mapping rules create*](api::ProjectLocationConversionWorkspaceMappingRuleCreateCall), [*locations conversion workspaces mapping rules delete*](api::ProjectLocationConversionWorkspaceMappingRuleDeleteCall), [*locations conversion workspaces mapping rules get*](api::ProjectLocationConversionWorkspaceMappingRuleGetCall), [*locations conversion workspaces mapping rules import*](api::ProjectLocationConversionWorkspaceMappingRuleImportCall), [*locations conversion workspaces mapping rules list*](api::ProjectLocationConversionWorkspaceMappingRuleListCall), [*locations conversion workspaces patch*](api::ProjectLocationConversionWorkspacePatchCall), [*locations conversion workspaces rollback*](api::ProjectLocationConversionWorkspaceRollbackCall), [*locations conversion workspaces search background jobs*](api::ProjectLocationConversionWorkspaceSearchBackgroundJobCall), [*locations conversion workspaces seed*](api::ProjectLocationConversionWorkspaceSeedCall), [*locations conversion workspaces set iam policy*](api::ProjectLocationConversionWorkspaceSetIamPolicyCall), [*locations conversion workspaces test iam permissions*](api::ProjectLocationConversionWorkspaceTestIamPermissionCall), [*locations fetch static ips*](api::ProjectLocationFetchStaticIpCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations migration jobs create*](api::ProjectLocationMigrationJobCreateCall), [*locations migration jobs delete*](api::ProjectLocationMigrationJobDeleteCall), [*locations migration jobs demote destination*](api::ProjectLocationMigrationJobDemoteDestinationCall), [*locations migration jobs generate ssh script*](api::ProjectLocationMigrationJobGenerateSshScriptCall), [*locations migration jobs generate tcp proxy script*](api::ProjectLocationMigrationJobGenerateTcpProxyScriptCall), [*locations migration jobs get*](api::ProjectLocationMigrationJobGetCall), [*locations migration jobs get iam policy*](api::ProjectLocationMigrationJobGetIamPolicyCall), [*locations migration jobs list*](api::ProjectLocationMigrationJobListCall), [*locations migration jobs patch*](api::ProjectLocationMigrationJobPatchCall), [*locations migration jobs promote*](api::ProjectLocationMigrationJobPromoteCall), [*locations migration jobs restart*](api::ProjectLocationMigrationJobRestartCall), [*locations migration jobs resume*](api::ProjectLocationMigrationJobResumeCall), [*locations migration jobs set iam policy*](api::ProjectLocationMigrationJobSetIamPolicyCall), [*locations migration jobs start*](api::ProjectLocationMigrationJobStartCall), [*locations migration jobs stop*](api::ProjectLocationMigrationJobStopCall), [*locations migration jobs test iam permissions*](api::ProjectLocationMigrationJobTestIamPermissionCall), [*locations migration jobs verify*](api::ProjectLocationMigrationJobVerifyCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations private connections create*](api::ProjectLocationPrivateConnectionCreateCall), [*locations private connections delete*](api::ProjectLocationPrivateConnectionDeleteCall), [*locations private connections get*](api::ProjectLocationPrivateConnectionGetCall), [*locations private connections get iam policy*](api::ProjectLocationPrivateConnectionGetIamPolicyCall), [*locations private connections list*](api::ProjectLocationPrivateConnectionListCall), [*locations private connections set iam policy*](api::ProjectLocationPrivateConnectionSetIamPolicyCall) and [*locations private connections test iam permissions*](api::ProjectLocationPrivateConnectionTestIamPermissionCall) @@ -74,8 +74,8 @@ //! let r = hub.projects().locations_private_connections_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -104,12 +104,12 @@ //! use std::default::Default; //! use datamigration1::{DatabaseMigrationService, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -154,10 +154,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -167,25 +167,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datapipelines1/src/lib.rs b/gen/datapipelines1/src/lib.rs index 303b389d01..80e9c29cc9 100644 --- a/gen/datapipelines1/src/lib.rs +++ b/gen/datapipelines1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datapipelines1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Datapipelines) ... +//! Handle the following *Resources* with ease from the central [hub](Datapipelines) ... //! //! * projects //! * [*locations pipelines create*](api::ProjectLocationPipelineCreateCall), [*locations pipelines delete*](api::ProjectLocationPipelineDeleteCall), [*locations pipelines get*](api::ProjectLocationPipelineGetCall), [*locations pipelines jobs list*](api::ProjectLocationPipelineJobListCall), [*locations pipelines list*](api::ProjectLocationPipelineListCall), [*locations pipelines patch*](api::ProjectLocationPipelinePatchCall), [*locations pipelines run*](api::ProjectLocationPipelineRunCall) and [*locations pipelines stop*](api::ProjectLocationPipelineStopCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().locations_pipelines_stop(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use datapipelines1::{Datapipelines, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dataplex1/src/lib.rs b/gen/dataplex1/src/lib.rs index 3a35cfc7cf..be55c9d795 100644 --- a/gen/dataplex1/src/lib.rs +++ b/gen/dataplex1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dataplex1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudDataplex) ... +//! Handle the following *Resources* with ease from the central [hub](CloudDataplex) ... //! //! * projects //! * [*locations aspect types get iam policy*](api::ProjectLocationAspectTypeGetIamPolicyCall), [*locations aspect types set iam policy*](api::ProjectLocationAspectTypeSetIamPolicyCall), [*locations aspect types test iam permissions*](api::ProjectLocationAspectTypeTestIamPermissionCall), [*locations data attribute bindings create*](api::ProjectLocationDataAttributeBindingCreateCall), [*locations data attribute bindings delete*](api::ProjectLocationDataAttributeBindingDeleteCall), [*locations data attribute bindings get*](api::ProjectLocationDataAttributeBindingGetCall), [*locations data attribute bindings get iam policy*](api::ProjectLocationDataAttributeBindingGetIamPolicyCall), [*locations data attribute bindings list*](api::ProjectLocationDataAttributeBindingListCall), [*locations data attribute bindings patch*](api::ProjectLocationDataAttributeBindingPatchCall), [*locations data attribute bindings set iam policy*](api::ProjectLocationDataAttributeBindingSetIamPolicyCall), [*locations data attribute bindings test iam permissions*](api::ProjectLocationDataAttributeBindingTestIamPermissionCall), [*locations data scans create*](api::ProjectLocationDataScanCreateCall), [*locations data scans delete*](api::ProjectLocationDataScanDeleteCall), [*locations data scans get*](api::ProjectLocationDataScanGetCall), [*locations data scans get iam policy*](api::ProjectLocationDataScanGetIamPolicyCall), [*locations data scans jobs get*](api::ProjectLocationDataScanJobGetCall), [*locations data scans jobs list*](api::ProjectLocationDataScanJobListCall), [*locations data scans list*](api::ProjectLocationDataScanListCall), [*locations data scans patch*](api::ProjectLocationDataScanPatchCall), [*locations data scans run*](api::ProjectLocationDataScanRunCall), [*locations data scans set iam policy*](api::ProjectLocationDataScanSetIamPolicyCall), [*locations data scans test iam permissions*](api::ProjectLocationDataScanTestIamPermissionCall), [*locations data taxonomies attributes create*](api::ProjectLocationDataTaxonomyAttributeCreateCall), [*locations data taxonomies attributes delete*](api::ProjectLocationDataTaxonomyAttributeDeleteCall), [*locations data taxonomies attributes get*](api::ProjectLocationDataTaxonomyAttributeGetCall), [*locations data taxonomies attributes get iam policy*](api::ProjectLocationDataTaxonomyAttributeGetIamPolicyCall), [*locations data taxonomies attributes list*](api::ProjectLocationDataTaxonomyAttributeListCall), [*locations data taxonomies attributes patch*](api::ProjectLocationDataTaxonomyAttributePatchCall), [*locations data taxonomies attributes set iam policy*](api::ProjectLocationDataTaxonomyAttributeSetIamPolicyCall), [*locations data taxonomies attributes test iam permissions*](api::ProjectLocationDataTaxonomyAttributeTestIamPermissionCall), [*locations data taxonomies create*](api::ProjectLocationDataTaxonomyCreateCall), [*locations data taxonomies delete*](api::ProjectLocationDataTaxonomyDeleteCall), [*locations data taxonomies get*](api::ProjectLocationDataTaxonomyGetCall), [*locations data taxonomies get iam policy*](api::ProjectLocationDataTaxonomyGetIamPolicyCall), [*locations data taxonomies list*](api::ProjectLocationDataTaxonomyListCall), [*locations data taxonomies patch*](api::ProjectLocationDataTaxonomyPatchCall), [*locations data taxonomies set iam policy*](api::ProjectLocationDataTaxonomySetIamPolicyCall), [*locations data taxonomies test iam permissions*](api::ProjectLocationDataTaxonomyTestIamPermissionCall), [*locations entry groups get iam policy*](api::ProjectLocationEntryGroupGetIamPolicyCall), [*locations entry groups set iam policy*](api::ProjectLocationEntryGroupSetIamPolicyCall), [*locations entry groups test iam permissions*](api::ProjectLocationEntryGroupTestIamPermissionCall), [*locations entry types get iam policy*](api::ProjectLocationEntryTypeGetIamPolicyCall), [*locations entry types set iam policy*](api::ProjectLocationEntryTypeSetIamPolicyCall), [*locations entry types test iam permissions*](api::ProjectLocationEntryTypeTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations governance rules get iam policy*](api::ProjectLocationGovernanceRuleGetIamPolicyCall), [*locations governance rules set iam policy*](api::ProjectLocationGovernanceRuleSetIamPolicyCall), [*locations governance rules test iam permissions*](api::ProjectLocationGovernanceRuleTestIamPermissionCall), [*locations lakes actions list*](api::ProjectLocationLakeActionListCall), [*locations lakes content create*](api::ProjectLocationLakeContentCreateCall), [*locations lakes content delete*](api::ProjectLocationLakeContentDeleteCall), [*locations lakes content get*](api::ProjectLocationLakeContentGetCall), [*locations lakes content get iam policy*](api::ProjectLocationLakeContentGetIamPolicyCall), [*locations lakes content list*](api::ProjectLocationLakeContentListCall), [*locations lakes content patch*](api::ProjectLocationLakeContentPatchCall), [*locations lakes content set iam policy*](api::ProjectLocationLakeContentSetIamPolicyCall), [*locations lakes content test iam permissions*](api::ProjectLocationLakeContentTestIamPermissionCall), [*locations lakes contentitems create*](api::ProjectLocationLakeContentitemCreateCall), [*locations lakes contentitems delete*](api::ProjectLocationLakeContentitemDeleteCall), [*locations lakes contentitems get*](api::ProjectLocationLakeContentitemGetCall), [*locations lakes contentitems get iam policy*](api::ProjectLocationLakeContentitemGetIamPolicyCall), [*locations lakes contentitems list*](api::ProjectLocationLakeContentitemListCall), [*locations lakes contentitems patch*](api::ProjectLocationLakeContentitemPatchCall), [*locations lakes contentitems set iam policy*](api::ProjectLocationLakeContentitemSetIamPolicyCall), [*locations lakes contentitems test iam permissions*](api::ProjectLocationLakeContentitemTestIamPermissionCall), [*locations lakes create*](api::ProjectLocationLakeCreateCall), [*locations lakes delete*](api::ProjectLocationLakeDeleteCall), [*locations lakes environments create*](api::ProjectLocationLakeEnvironmentCreateCall), [*locations lakes environments delete*](api::ProjectLocationLakeEnvironmentDeleteCall), [*locations lakes environments get*](api::ProjectLocationLakeEnvironmentGetCall), [*locations lakes environments get iam policy*](api::ProjectLocationLakeEnvironmentGetIamPolicyCall), [*locations lakes environments list*](api::ProjectLocationLakeEnvironmentListCall), [*locations lakes environments patch*](api::ProjectLocationLakeEnvironmentPatchCall), [*locations lakes environments sessions list*](api::ProjectLocationLakeEnvironmentSessionListCall), [*locations lakes environments set iam policy*](api::ProjectLocationLakeEnvironmentSetIamPolicyCall), [*locations lakes environments test iam permissions*](api::ProjectLocationLakeEnvironmentTestIamPermissionCall), [*locations lakes get*](api::ProjectLocationLakeGetCall), [*locations lakes get iam policy*](api::ProjectLocationLakeGetIamPolicyCall), [*locations lakes list*](api::ProjectLocationLakeListCall), [*locations lakes patch*](api::ProjectLocationLakePatchCall), [*locations lakes set iam policy*](api::ProjectLocationLakeSetIamPolicyCall), [*locations lakes tasks create*](api::ProjectLocationLakeTaskCreateCall), [*locations lakes tasks delete*](api::ProjectLocationLakeTaskDeleteCall), [*locations lakes tasks get*](api::ProjectLocationLakeTaskGetCall), [*locations lakes tasks get iam policy*](api::ProjectLocationLakeTaskGetIamPolicyCall), [*locations lakes tasks jobs cancel*](api::ProjectLocationLakeTaskJobCancelCall), [*locations lakes tasks jobs get*](api::ProjectLocationLakeTaskJobGetCall), [*locations lakes tasks jobs list*](api::ProjectLocationLakeTaskJobListCall), [*locations lakes tasks list*](api::ProjectLocationLakeTaskListCall), [*locations lakes tasks patch*](api::ProjectLocationLakeTaskPatchCall), [*locations lakes tasks run*](api::ProjectLocationLakeTaskRunCall), [*locations lakes tasks set iam policy*](api::ProjectLocationLakeTaskSetIamPolicyCall), [*locations lakes tasks test iam permissions*](api::ProjectLocationLakeTaskTestIamPermissionCall), [*locations lakes test iam permissions*](api::ProjectLocationLakeTestIamPermissionCall), [*locations lakes zones actions list*](api::ProjectLocationLakeZoneActionListCall), [*locations lakes zones assets actions list*](api::ProjectLocationLakeZoneAssetActionListCall), [*locations lakes zones assets create*](api::ProjectLocationLakeZoneAssetCreateCall), [*locations lakes zones assets delete*](api::ProjectLocationLakeZoneAssetDeleteCall), [*locations lakes zones assets get*](api::ProjectLocationLakeZoneAssetGetCall), [*locations lakes zones assets get iam policy*](api::ProjectLocationLakeZoneAssetGetIamPolicyCall), [*locations lakes zones assets list*](api::ProjectLocationLakeZoneAssetListCall), [*locations lakes zones assets patch*](api::ProjectLocationLakeZoneAssetPatchCall), [*locations lakes zones assets set iam policy*](api::ProjectLocationLakeZoneAssetSetIamPolicyCall), [*locations lakes zones assets test iam permissions*](api::ProjectLocationLakeZoneAssetTestIamPermissionCall), [*locations lakes zones create*](api::ProjectLocationLakeZoneCreateCall), [*locations lakes zones delete*](api::ProjectLocationLakeZoneDeleteCall), [*locations lakes zones entities create*](api::ProjectLocationLakeZoneEntityCreateCall), [*locations lakes zones entities delete*](api::ProjectLocationLakeZoneEntityDeleteCall), [*locations lakes zones entities get*](api::ProjectLocationLakeZoneEntityGetCall), [*locations lakes zones entities list*](api::ProjectLocationLakeZoneEntityListCall), [*locations lakes zones entities partitions create*](api::ProjectLocationLakeZoneEntityPartitionCreateCall), [*locations lakes zones entities partitions delete*](api::ProjectLocationLakeZoneEntityPartitionDeleteCall), [*locations lakes zones entities partitions get*](api::ProjectLocationLakeZoneEntityPartitionGetCall), [*locations lakes zones entities partitions list*](api::ProjectLocationLakeZoneEntityPartitionListCall), [*locations lakes zones entities update*](api::ProjectLocationLakeZoneEntityUpdateCall), [*locations lakes zones get*](api::ProjectLocationLakeZoneGetCall), [*locations lakes zones get iam policy*](api::ProjectLocationLakeZoneGetIamPolicyCall), [*locations lakes zones list*](api::ProjectLocationLakeZoneListCall), [*locations lakes zones patch*](api::ProjectLocationLakeZonePatchCall), [*locations lakes zones set iam policy*](api::ProjectLocationLakeZoneSetIamPolicyCall), [*locations lakes zones test iam permissions*](api::ProjectLocationLakeZoneTestIamPermissionCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -79,8 +79,8 @@ //! let r = hub.projects().locations_lakes_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -108,12 +108,12 @@ //! use std::default::Default; //! use dataplex1::{CloudDataplex, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -150,10 +150,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -163,25 +163,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dataproc1/src/lib.rs b/gen/dataproc1/src/lib.rs index b6490a8451..0a91fa13e3 100644 --- a/gen/dataproc1/src/lib.rs +++ b/gen/dataproc1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dataproc1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dataproc) ... +//! Handle the following *Resources* with ease from the central [hub](Dataproc) ... //! //! * projects //! * [*locations autoscaling policies create*](api::ProjectLocationAutoscalingPolicyCreateCall), [*locations autoscaling policies delete*](api::ProjectLocationAutoscalingPolicyDeleteCall), [*locations autoscaling policies get*](api::ProjectLocationAutoscalingPolicyGetCall), [*locations autoscaling policies get iam policy*](api::ProjectLocationAutoscalingPolicyGetIamPolicyCall), [*locations autoscaling policies list*](api::ProjectLocationAutoscalingPolicyListCall), [*locations autoscaling policies set iam policy*](api::ProjectLocationAutoscalingPolicySetIamPolicyCall), [*locations autoscaling policies test iam permissions*](api::ProjectLocationAutoscalingPolicyTestIamPermissionCall), [*locations autoscaling policies update*](api::ProjectLocationAutoscalingPolicyUpdateCall), [*locations batches create*](api::ProjectLocationBatchCreateCall), [*locations batches delete*](api::ProjectLocationBatchDeleteCall), [*locations batches get*](api::ProjectLocationBatchGetCall), [*locations batches list*](api::ProjectLocationBatchListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations session templates create*](api::ProjectLocationSessionTemplateCreateCall), [*locations session templates delete*](api::ProjectLocationSessionTemplateDeleteCall), [*locations session templates get*](api::ProjectLocationSessionTemplateGetCall), [*locations session templates list*](api::ProjectLocationSessionTemplateListCall), [*locations session templates patch*](api::ProjectLocationSessionTemplatePatchCall), [*locations sessions create*](api::ProjectLocationSessionCreateCall), [*locations sessions delete*](api::ProjectLocationSessionDeleteCall), [*locations sessions get*](api::ProjectLocationSessionGetCall), [*locations sessions list*](api::ProjectLocationSessionListCall), [*locations sessions terminate*](api::ProjectLocationSessionTerminateCall), [*locations workflow templates create*](api::ProjectLocationWorkflowTemplateCreateCall), [*locations workflow templates delete*](api::ProjectLocationWorkflowTemplateDeleteCall), [*locations workflow templates get*](api::ProjectLocationWorkflowTemplateGetCall), [*locations workflow templates get iam policy*](api::ProjectLocationWorkflowTemplateGetIamPolicyCall), [*locations workflow templates instantiate*](api::ProjectLocationWorkflowTemplateInstantiateCall), [*locations workflow templates instantiate inline*](api::ProjectLocationWorkflowTemplateInstantiateInlineCall), [*locations workflow templates list*](api::ProjectLocationWorkflowTemplateListCall), [*locations workflow templates set iam policy*](api::ProjectLocationWorkflowTemplateSetIamPolicyCall), [*locations workflow templates test iam permissions*](api::ProjectLocationWorkflowTemplateTestIamPermissionCall), [*locations workflow templates update*](api::ProjectLocationWorkflowTemplateUpdateCall), [*regions autoscaling policies create*](api::ProjectRegionAutoscalingPolicyCreateCall), [*regions autoscaling policies delete*](api::ProjectRegionAutoscalingPolicyDeleteCall), [*regions autoscaling policies get*](api::ProjectRegionAutoscalingPolicyGetCall), [*regions autoscaling policies get iam policy*](api::ProjectRegionAutoscalingPolicyGetIamPolicyCall), [*regions autoscaling policies list*](api::ProjectRegionAutoscalingPolicyListCall), [*regions autoscaling policies set iam policy*](api::ProjectRegionAutoscalingPolicySetIamPolicyCall), [*regions autoscaling policies test iam permissions*](api::ProjectRegionAutoscalingPolicyTestIamPermissionCall), [*regions autoscaling policies update*](api::ProjectRegionAutoscalingPolicyUpdateCall), [*regions clusters create*](api::ProjectRegionClusterCreateCall), [*regions clusters delete*](api::ProjectRegionClusterDeleteCall), [*regions clusters diagnose*](api::ProjectRegionClusterDiagnoseCall), [*regions clusters get*](api::ProjectRegionClusterGetCall), [*regions clusters get iam policy*](api::ProjectRegionClusterGetIamPolicyCall), [*regions clusters inject credentials*](api::ProjectRegionClusterInjectCredentialCall), [*regions clusters list*](api::ProjectRegionClusterListCall), [*regions clusters node groups create*](api::ProjectRegionClusterNodeGroupCreateCall), [*regions clusters node groups get*](api::ProjectRegionClusterNodeGroupGetCall), [*regions clusters node groups repair*](api::ProjectRegionClusterNodeGroupRepairCall), [*regions clusters node groups resize*](api::ProjectRegionClusterNodeGroupResizeCall), [*regions clusters patch*](api::ProjectRegionClusterPatchCall), [*regions clusters repair*](api::ProjectRegionClusterRepairCall), [*regions clusters set iam policy*](api::ProjectRegionClusterSetIamPolicyCall), [*regions clusters start*](api::ProjectRegionClusterStartCall), [*regions clusters stop*](api::ProjectRegionClusterStopCall), [*regions clusters test iam permissions*](api::ProjectRegionClusterTestIamPermissionCall), [*regions jobs cancel*](api::ProjectRegionJobCancelCall), [*regions jobs delete*](api::ProjectRegionJobDeleteCall), [*regions jobs get*](api::ProjectRegionJobGetCall), [*regions jobs get iam policy*](api::ProjectRegionJobGetIamPolicyCall), [*regions jobs list*](api::ProjectRegionJobListCall), [*regions jobs patch*](api::ProjectRegionJobPatchCall), [*regions jobs set iam policy*](api::ProjectRegionJobSetIamPolicyCall), [*regions jobs submit*](api::ProjectRegionJobSubmitCall), [*regions jobs submit as operation*](api::ProjectRegionJobSubmitAsOperationCall), [*regions jobs test iam permissions*](api::ProjectRegionJobTestIamPermissionCall), [*regions operations cancel*](api::ProjectRegionOperationCancelCall), [*regions operations delete*](api::ProjectRegionOperationDeleteCall), [*regions operations get*](api::ProjectRegionOperationGetCall), [*regions operations get iam policy*](api::ProjectRegionOperationGetIamPolicyCall), [*regions operations list*](api::ProjectRegionOperationListCall), [*regions operations set iam policy*](api::ProjectRegionOperationSetIamPolicyCall), [*regions operations test iam permissions*](api::ProjectRegionOperationTestIamPermissionCall), [*regions workflow templates create*](api::ProjectRegionWorkflowTemplateCreateCall), [*regions workflow templates delete*](api::ProjectRegionWorkflowTemplateDeleteCall), [*regions workflow templates get*](api::ProjectRegionWorkflowTemplateGetCall), [*regions workflow templates get iam policy*](api::ProjectRegionWorkflowTemplateGetIamPolicyCall), [*regions workflow templates instantiate*](api::ProjectRegionWorkflowTemplateInstantiateCall), [*regions workflow templates instantiate inline*](api::ProjectRegionWorkflowTemplateInstantiateInlineCall), [*regions workflow templates list*](api::ProjectRegionWorkflowTemplateListCall), [*regions workflow templates set iam policy*](api::ProjectRegionWorkflowTemplateSetIamPolicyCall), [*regions workflow templates test iam permissions*](api::ProjectRegionWorkflowTemplateTestIamPermissionCall) and [*regions workflow templates update*](api::ProjectRegionWorkflowTemplateUpdateCall) @@ -71,8 +71,8 @@ //! let r = hub.projects().regions_workflow_templates_instantiate_inline(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -101,12 +101,12 @@ //! use std::default::Default; //! use dataproc1::{Dataproc, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -150,10 +150,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -163,25 +163,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datastore1/src/lib.rs b/gen/datastore1/src/lib.rs index 904f5eb097..f24465944b 100644 --- a/gen/datastore1/src/lib.rs +++ b/gen/datastore1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datastore1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Datastore) ... +//! Handle the following *Resources* with ease from the central [hub](Datastore) ... //! //! * projects //! * [*allocate ids*](api::ProjectAllocateIdCall), [*begin transaction*](api::ProjectBeginTransactionCall), [*commit*](api::ProjectCommitCall), [*export*](api::ProjectExportCall), [*import*](api::ProjectImportCall), [*indexes create*](api::ProjectIndexCreateCall), [*indexes delete*](api::ProjectIndexDeleteCall), [*indexes get*](api::ProjectIndexGetCall), [*indexes list*](api::ProjectIndexListCall), [*lookup*](api::ProjectLookupCall), [*operations cancel*](api::ProjectOperationCancelCall), [*operations delete*](api::ProjectOperationDeleteCall), [*operations get*](api::ProjectOperationGetCall), [*operations list*](api::ProjectOperationListCall), [*reserve ids*](api::ProjectReserveIdCall), [*rollback*](api::ProjectRollbackCall), [*run aggregation query*](api::ProjectRunAggregationQueryCall) and [*run query*](api::ProjectRunQueryCall) @@ -54,8 +54,8 @@ //! let r = hub.projects().import(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use datastore1::{Datastore, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datastore1_beta3/src/lib.rs b/gen/datastore1_beta3/src/lib.rs index 579f62d0f4..445683efa3 100644 --- a/gen/datastore1_beta3/src/lib.rs +++ b/gen/datastore1_beta3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datastore1_beta3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Datastore) ... +//! Handle the following *Resources* with ease from the central [hub](Datastore) ... //! //! * projects //! * [*allocate ids*](api::ProjectAllocateIdCall), [*begin transaction*](api::ProjectBeginTransactionCall), [*commit*](api::ProjectCommitCall), [*lookup*](api::ProjectLookupCall), [*reserve ids*](api::ProjectReserveIdCall), [*rollback*](api::ProjectRollbackCall), [*run aggregation query*](api::ProjectRunAggregationQueryCall) and [*run query*](api::ProjectRunQueryCall) @@ -50,8 +50,8 @@ //! let r = hub.projects().lookup(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use datastore1_beta3::{Datastore, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/datastream1/src/lib.rs b/gen/datastream1/src/lib.rs index dc361f44ba..4ff1809df1 100644 --- a/gen/datastream1/src/lib.rs +++ b/gen/datastream1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/datastream1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Datastream) ... +//! Handle the following *Resources* with ease from the central [hub](Datastream) ... //! //! * projects //! * [*locations connection profiles create*](api::ProjectLocationConnectionProfileCreateCall), [*locations connection profiles delete*](api::ProjectLocationConnectionProfileDeleteCall), [*locations connection profiles discover*](api::ProjectLocationConnectionProfileDiscoverCall), [*locations connection profiles get*](api::ProjectLocationConnectionProfileGetCall), [*locations connection profiles list*](api::ProjectLocationConnectionProfileListCall), [*locations connection profiles patch*](api::ProjectLocationConnectionProfilePatchCall), [*locations fetch static ips*](api::ProjectLocationFetchStaticIpCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations private connections create*](api::ProjectLocationPrivateConnectionCreateCall), [*locations private connections delete*](api::ProjectLocationPrivateConnectionDeleteCall), [*locations private connections get*](api::ProjectLocationPrivateConnectionGetCall), [*locations private connections list*](api::ProjectLocationPrivateConnectionListCall), [*locations private connections routes create*](api::ProjectLocationPrivateConnectionRouteCreateCall), [*locations private connections routes delete*](api::ProjectLocationPrivateConnectionRouteDeleteCall), [*locations private connections routes get*](api::ProjectLocationPrivateConnectionRouteGetCall), [*locations private connections routes list*](api::ProjectLocationPrivateConnectionRouteListCall), [*locations streams create*](api::ProjectLocationStreamCreateCall), [*locations streams delete*](api::ProjectLocationStreamDeleteCall), [*locations streams get*](api::ProjectLocationStreamGetCall), [*locations streams list*](api::ProjectLocationStreamListCall), [*locations streams objects get*](api::ProjectLocationStreamObjectGetCall), [*locations streams objects list*](api::ProjectLocationStreamObjectListCall), [*locations streams objects lookup*](api::ProjectLocationStreamObjectLookupCall), [*locations streams objects start backfill job*](api::ProjectLocationStreamObjectStartBackfillJobCall), [*locations streams objects stop backfill job*](api::ProjectLocationStreamObjectStopBackfillJobCall), [*locations streams patch*](api::ProjectLocationStreamPatchCall) and [*locations streams run*](api::ProjectLocationStreamRunCall) @@ -61,8 +61,8 @@ //! let r = hub.projects().locations_streams_run(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use datastream1::{Datastream, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/deploymentmanager2/src/lib.rs b/gen/deploymentmanager2/src/lib.rs index 19f07b997c..999c8f6b62 100644 --- a/gen/deploymentmanager2/src/lib.rs +++ b/gen/deploymentmanager2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/deploymentmanager2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DeploymentManager) ... +//! Handle the following *Resources* with ease from the central [hub](DeploymentManager) ... //! //! * [deployments](api::Deployment) //! * [*cancel preview*](api::DeploymentCancelPreviewCall), [*delete*](api::DeploymentDeleteCall), [*get*](api::DeploymentGetCall), [*get iam policy*](api::DeploymentGetIamPolicyCall), [*insert*](api::DeploymentInsertCall), [*list*](api::DeploymentListCall), [*patch*](api::DeploymentPatchCall), [*set iam policy*](api::DeploymentSetIamPolicyCall), [*stop*](api::DeploymentStopCall), [*test iam permissions*](api::DeploymentTestIamPermissionCall) and [*update*](api::DeploymentUpdateCall) @@ -68,8 +68,8 @@ //! let r = hub.deployments().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -98,12 +98,12 @@ //! use std::default::Default; //! use deploymentmanager2::{DeploymentManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -147,10 +147,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -160,25 +160,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/deploymentmanager2_beta2/src/lib.rs b/gen/deploymentmanager2_beta2/src/lib.rs index e714ab8be4..4c9227f064 100644 --- a/gen/deploymentmanager2_beta2/src/lib.rs +++ b/gen/deploymentmanager2_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/deploymentmanager2_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DeploymentManager) ... +//! Handle the following *Resources* with ease from the central [hub](DeploymentManager) ... //! //! * [deployments](api::Deployment) //! * [*delete*](api::DeploymentDeleteCall), [*get*](api::DeploymentGetCall), [*insert*](api::DeploymentInsertCall), [*list*](api::DeploymentListCall), [*patch*](api::DeploymentPatchCall) and [*update*](api::DeploymentUpdateCall) @@ -63,8 +63,8 @@ //! let r = hub.operations().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -93,12 +93,12 @@ //! use std::default::Default; //! use deploymentmanager2_beta2::{DeploymentManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -142,10 +142,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -155,25 +155,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dfareporting2d8/src/lib.rs b/gen/dfareporting2d8/src/lib.rs index 7c08c4d87e..c978675e56 100644 --- a/gen/dfareporting2d8/src/lib.rs +++ b/gen/dfareporting2d8/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dfareporting2d8). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... +//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... //! //! * [account active ad summaries](api::AccountActiveAdSummary) //! * [*get*](api::AccountActiveAdSummaryGetCall) @@ -186,8 +186,8 @@ //! let r = hub.reports().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -215,12 +215,12 @@ //! use std::default::Default; //! use dfareporting2d8::{Dfareporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -260,10 +260,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -273,25 +273,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dfareporting3/src/lib.rs b/gen/dfareporting3/src/lib.rs index 89a9bf4ce9..baba3f8bc3 100644 --- a/gen/dfareporting3/src/lib.rs +++ b/gen/dfareporting3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dfareporting3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... +//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... //! //! * [account active ad summaries](api::AccountActiveAdSummary) //! * [*get*](api::AccountActiveAdSummaryGetCall) @@ -186,8 +186,8 @@ //! let r = hub.reports().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -215,12 +215,12 @@ //! use std::default::Default; //! use dfareporting3::{Dfareporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -260,10 +260,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -273,25 +273,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dfareporting3d2/src/lib.rs b/gen/dfareporting3d2/src/lib.rs index c120e382e2..3224b1c36c 100644 --- a/gen/dfareporting3d2/src/lib.rs +++ b/gen/dfareporting3d2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dfareporting3d2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... +//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... //! //! * [account active ad summaries](api::AccountActiveAdSummary) //! * [*get*](api::AccountActiveAdSummaryGetCall) @@ -188,8 +188,8 @@ //! let r = hub.reports().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -217,12 +217,12 @@ //! use std::default::Default; //! use dfareporting3d2::{Dfareporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -262,10 +262,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -275,25 +275,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dfareporting3d3/src/lib.rs b/gen/dfareporting3d3/src/lib.rs index 5dc804436d..1382fe0291 100644 --- a/gen/dfareporting3d3/src/lib.rs +++ b/gen/dfareporting3d3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dfareporting3d3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... +//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... //! //! * [account active ad summaries](api::AccountActiveAdSummary) //! * [*get*](api::AccountActiveAdSummaryGetCall) @@ -186,8 +186,8 @@ //! let r = hub.reports().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -215,12 +215,12 @@ //! use std::default::Default; //! use dfareporting3d3::{Dfareporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -260,10 +260,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -273,25 +273,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dfareporting3d4/src/lib.rs b/gen/dfareporting3d4/src/lib.rs index 6030256104..942e07760d 100644 --- a/gen/dfareporting3d4/src/lib.rs +++ b/gen/dfareporting3d4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dfareporting3d4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... +//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... //! //! * [account active ad summaries](api::AccountActiveAdSummary) //! * [*get*](api::AccountActiveAdSummaryGetCall) @@ -188,8 +188,8 @@ //! let r = hub.reports().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -217,12 +217,12 @@ //! use std::default::Default; //! use dfareporting3d4::{Dfareporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -262,10 +262,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -275,25 +275,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dfareporting3d5/src/lib.rs b/gen/dfareporting3d5/src/lib.rs index d4b03f4375..3672b84611 100644 --- a/gen/dfareporting3d5/src/lib.rs +++ b/gen/dfareporting3d5/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dfareporting3d5). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... +//! Handle the following *Resources* with ease from the central [hub](Dfareporting) ... //! //! * media //! * [*upload*](api::MediaUploadCall) @@ -54,8 +54,8 @@ //! let r = hub.media().upload(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use dfareporting3d5::{Dfareporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dialogflow2/src/lib.rs b/gen/dialogflow2/src/lib.rs index f54464d103..5656ea678a 100644 --- a/gen/dialogflow2/src/lib.rs +++ b/gen/dialogflow2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dialogflow2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dialogflow) ... +//! Handle the following *Resources* with ease from the central [hub](Dialogflow) ... //! //! * projects //! * [*agent entity types batch delete*](api::ProjectAgentEntityTypeBatchDeleteCall), [*agent entity types batch update*](api::ProjectAgentEntityTypeBatchUpdateCall), [*agent entity types create*](api::ProjectAgentEntityTypeCreateCall), [*agent entity types delete*](api::ProjectAgentEntityTypeDeleteCall), [*agent entity types entities batch create*](api::ProjectAgentEntityTypeEntityBatchCreateCall), [*agent entity types entities batch delete*](api::ProjectAgentEntityTypeEntityBatchDeleteCall), [*agent entity types entities batch update*](api::ProjectAgentEntityTypeEntityBatchUpdateCall), [*agent entity types get*](api::ProjectAgentEntityTypeGetCall), [*agent entity types list*](api::ProjectAgentEntityTypeListCall), [*agent entity types patch*](api::ProjectAgentEntityTypePatchCall), [*agent environments create*](api::ProjectAgentEnvironmentCreateCall), [*agent environments delete*](api::ProjectAgentEnvironmentDeleteCall), [*agent environments get*](api::ProjectAgentEnvironmentGetCall), [*agent environments get history*](api::ProjectAgentEnvironmentGetHistoryCall), [*agent environments intents list*](api::ProjectAgentEnvironmentIntentListCall), [*agent environments list*](api::ProjectAgentEnvironmentListCall), [*agent environments patch*](api::ProjectAgentEnvironmentPatchCall), [*agent environments users sessions contexts create*](api::ProjectAgentEnvironmentUserSessionContextCreateCall), [*agent environments users sessions contexts delete*](api::ProjectAgentEnvironmentUserSessionContextDeleteCall), [*agent environments users sessions contexts get*](api::ProjectAgentEnvironmentUserSessionContextGetCall), [*agent environments users sessions contexts list*](api::ProjectAgentEnvironmentUserSessionContextListCall), [*agent environments users sessions contexts patch*](api::ProjectAgentEnvironmentUserSessionContextPatchCall), [*agent environments users sessions delete contexts*](api::ProjectAgentEnvironmentUserSessionDeleteContextCall), [*agent environments users sessions detect intent*](api::ProjectAgentEnvironmentUserSessionDetectIntentCall), [*agent environments users sessions entity types create*](api::ProjectAgentEnvironmentUserSessionEntityTypeCreateCall), [*agent environments users sessions entity types delete*](api::ProjectAgentEnvironmentUserSessionEntityTypeDeleteCall), [*agent environments users sessions entity types get*](api::ProjectAgentEnvironmentUserSessionEntityTypeGetCall), [*agent environments users sessions entity types list*](api::ProjectAgentEnvironmentUserSessionEntityTypeListCall), [*agent environments users sessions entity types patch*](api::ProjectAgentEnvironmentUserSessionEntityTypePatchCall), [*agent export*](api::ProjectAgentExportCall), [*agent get fulfillment*](api::ProjectAgentGetFulfillmentCall), [*agent get validation result*](api::ProjectAgentGetValidationResultCall), [*agent import*](api::ProjectAgentImportCall), [*agent intents batch delete*](api::ProjectAgentIntentBatchDeleteCall), [*agent intents batch update*](api::ProjectAgentIntentBatchUpdateCall), [*agent intents create*](api::ProjectAgentIntentCreateCall), [*agent intents delete*](api::ProjectAgentIntentDeleteCall), [*agent intents get*](api::ProjectAgentIntentGetCall), [*agent intents list*](api::ProjectAgentIntentListCall), [*agent intents patch*](api::ProjectAgentIntentPatchCall), [*agent knowledge bases create*](api::ProjectAgentKnowledgeBaseCreateCall), [*agent knowledge bases delete*](api::ProjectAgentKnowledgeBaseDeleteCall), [*agent knowledge bases documents create*](api::ProjectAgentKnowledgeBaseDocumentCreateCall), [*agent knowledge bases documents delete*](api::ProjectAgentKnowledgeBaseDocumentDeleteCall), [*agent knowledge bases documents get*](api::ProjectAgentKnowledgeBaseDocumentGetCall), [*agent knowledge bases documents list*](api::ProjectAgentKnowledgeBaseDocumentListCall), [*agent knowledge bases documents patch*](api::ProjectAgentKnowledgeBaseDocumentPatchCall), [*agent knowledge bases documents reload*](api::ProjectAgentKnowledgeBaseDocumentReloadCall), [*agent knowledge bases get*](api::ProjectAgentKnowledgeBaseGetCall), [*agent knowledge bases list*](api::ProjectAgentKnowledgeBaseListCall), [*agent knowledge bases patch*](api::ProjectAgentKnowledgeBasePatchCall), [*agent restore*](api::ProjectAgentRestoreCall), [*agent search*](api::ProjectAgentSearchCall), [*agent sessions contexts create*](api::ProjectAgentSessionContextCreateCall), [*agent sessions contexts delete*](api::ProjectAgentSessionContextDeleteCall), [*agent sessions contexts get*](api::ProjectAgentSessionContextGetCall), [*agent sessions contexts list*](api::ProjectAgentSessionContextListCall), [*agent sessions contexts patch*](api::ProjectAgentSessionContextPatchCall), [*agent sessions delete contexts*](api::ProjectAgentSessionDeleteContextCall), [*agent sessions detect intent*](api::ProjectAgentSessionDetectIntentCall), [*agent sessions entity types create*](api::ProjectAgentSessionEntityTypeCreateCall), [*agent sessions entity types delete*](api::ProjectAgentSessionEntityTypeDeleteCall), [*agent sessions entity types get*](api::ProjectAgentSessionEntityTypeGetCall), [*agent sessions entity types list*](api::ProjectAgentSessionEntityTypeListCall), [*agent sessions entity types patch*](api::ProjectAgentSessionEntityTypePatchCall), [*agent train*](api::ProjectAgentTrainCall), [*agent update fulfillment*](api::ProjectAgentUpdateFulfillmentCall), [*agent versions create*](api::ProjectAgentVersionCreateCall), [*agent versions delete*](api::ProjectAgentVersionDeleteCall), [*agent versions get*](api::ProjectAgentVersionGetCall), [*agent versions list*](api::ProjectAgentVersionListCall), [*agent versions patch*](api::ProjectAgentVersionPatchCall), [*answer records list*](api::ProjectAnswerRecordListCall), [*answer records patch*](api::ProjectAnswerRecordPatchCall), [*conversation datasets get*](api::ProjectConversationDatasetGetCall), [*conversation datasets import conversation data*](api::ProjectConversationDatasetImportConversationDataCall), [*conversation datasets list*](api::ProjectConversationDatasetListCall), [*conversation models create*](api::ProjectConversationModelCreateCall), [*conversation models delete*](api::ProjectConversationModelDeleteCall), [*conversation models deploy*](api::ProjectConversationModelDeployCall), [*conversation models evaluations get*](api::ProjectConversationModelEvaluationGetCall), [*conversation models evaluations list*](api::ProjectConversationModelEvaluationListCall), [*conversation models get*](api::ProjectConversationModelGetCall), [*conversation models list*](api::ProjectConversationModelListCall), [*conversation models undeploy*](api::ProjectConversationModelUndeployCall), [*conversation profiles clear suggestion feature config*](api::ProjectConversationProfileClearSuggestionFeatureConfigCall), [*conversation profiles create*](api::ProjectConversationProfileCreateCall), [*conversation profiles delete*](api::ProjectConversationProfileDeleteCall), [*conversation profiles get*](api::ProjectConversationProfileGetCall), [*conversation profiles list*](api::ProjectConversationProfileListCall), [*conversation profiles patch*](api::ProjectConversationProfilePatchCall), [*conversation profiles set suggestion feature config*](api::ProjectConversationProfileSetSuggestionFeatureConfigCall), [*conversations complete*](api::ProjectConversationCompleteCall), [*conversations create*](api::ProjectConversationCreateCall), [*conversations get*](api::ProjectConversationGetCall), [*conversations list*](api::ProjectConversationListCall), [*conversations messages list*](api::ProjectConversationMessageListCall), [*conversations participants analyze content*](api::ProjectConversationParticipantAnalyzeContentCall), [*conversations participants create*](api::ProjectConversationParticipantCreateCall), [*conversations participants get*](api::ProjectConversationParticipantGetCall), [*conversations participants list*](api::ProjectConversationParticipantListCall), [*conversations participants patch*](api::ProjectConversationParticipantPatchCall), [*conversations participants suggestions suggest articles*](api::ProjectConversationParticipantSuggestionSuggestArticleCall), [*conversations participants suggestions suggest faq answers*](api::ProjectConversationParticipantSuggestionSuggestFaqAnswerCall), [*conversations participants suggestions suggest smart replies*](api::ProjectConversationParticipantSuggestionSuggestSmartReplyCall), [*conversations suggestions search knowledge*](api::ProjectConversationSuggestionSearchKnowledgeCall), [*conversations suggestions suggest conversation summary*](api::ProjectConversationSuggestionSuggestConversationSummaryCall), [*delete agent*](api::ProjectDeleteAgentCall), [*get agent*](api::ProjectGetAgentCall), [*knowledge bases create*](api::ProjectKnowledgeBaseCreateCall), [*knowledge bases delete*](api::ProjectKnowledgeBaseDeleteCall), [*knowledge bases documents create*](api::ProjectKnowledgeBaseDocumentCreateCall), [*knowledge bases documents delete*](api::ProjectKnowledgeBaseDocumentDeleteCall), [*knowledge bases documents export*](api::ProjectKnowledgeBaseDocumentExportCall), [*knowledge bases documents get*](api::ProjectKnowledgeBaseDocumentGetCall), [*knowledge bases documents import*](api::ProjectKnowledgeBaseDocumentImportCall), [*knowledge bases documents list*](api::ProjectKnowledgeBaseDocumentListCall), [*knowledge bases documents patch*](api::ProjectKnowledgeBaseDocumentPatchCall), [*knowledge bases documents reload*](api::ProjectKnowledgeBaseDocumentReloadCall), [*knowledge bases get*](api::ProjectKnowledgeBaseGetCall), [*knowledge bases list*](api::ProjectKnowledgeBaseListCall), [*knowledge bases patch*](api::ProjectKnowledgeBasePatchCall), [*locations agent entity types batch delete*](api::ProjectLocationAgentEntityTypeBatchDeleteCall), [*locations agent entity types batch update*](api::ProjectLocationAgentEntityTypeBatchUpdateCall), [*locations agent entity types create*](api::ProjectLocationAgentEntityTypeCreateCall), [*locations agent entity types delete*](api::ProjectLocationAgentEntityTypeDeleteCall), [*locations agent entity types entities batch create*](api::ProjectLocationAgentEntityTypeEntityBatchCreateCall), [*locations agent entity types entities batch delete*](api::ProjectLocationAgentEntityTypeEntityBatchDeleteCall), [*locations agent entity types entities batch update*](api::ProjectLocationAgentEntityTypeEntityBatchUpdateCall), [*locations agent entity types get*](api::ProjectLocationAgentEntityTypeGetCall), [*locations agent entity types list*](api::ProjectLocationAgentEntityTypeListCall), [*locations agent entity types patch*](api::ProjectLocationAgentEntityTypePatchCall), [*locations agent environments create*](api::ProjectLocationAgentEnvironmentCreateCall), [*locations agent environments delete*](api::ProjectLocationAgentEnvironmentDeleteCall), [*locations agent environments get*](api::ProjectLocationAgentEnvironmentGetCall), [*locations agent environments get history*](api::ProjectLocationAgentEnvironmentGetHistoryCall), [*locations agent environments intents list*](api::ProjectLocationAgentEnvironmentIntentListCall), [*locations agent environments list*](api::ProjectLocationAgentEnvironmentListCall), [*locations agent environments patch*](api::ProjectLocationAgentEnvironmentPatchCall), [*locations agent environments users sessions contexts create*](api::ProjectLocationAgentEnvironmentUserSessionContextCreateCall), [*locations agent environments users sessions contexts delete*](api::ProjectLocationAgentEnvironmentUserSessionContextDeleteCall), [*locations agent environments users sessions contexts get*](api::ProjectLocationAgentEnvironmentUserSessionContextGetCall), [*locations agent environments users sessions contexts list*](api::ProjectLocationAgentEnvironmentUserSessionContextListCall), [*locations agent environments users sessions contexts patch*](api::ProjectLocationAgentEnvironmentUserSessionContextPatchCall), [*locations agent environments users sessions delete contexts*](api::ProjectLocationAgentEnvironmentUserSessionDeleteContextCall), [*locations agent environments users sessions detect intent*](api::ProjectLocationAgentEnvironmentUserSessionDetectIntentCall), [*locations agent environments users sessions entity types create*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypeCreateCall), [*locations agent environments users sessions entity types delete*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypeDeleteCall), [*locations agent environments users sessions entity types get*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypeGetCall), [*locations agent environments users sessions entity types list*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypeListCall), [*locations agent environments users sessions entity types patch*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypePatchCall), [*locations agent export*](api::ProjectLocationAgentExportCall), [*locations agent get fulfillment*](api::ProjectLocationAgentGetFulfillmentCall), [*locations agent get validation result*](api::ProjectLocationAgentGetValidationResultCall), [*locations agent import*](api::ProjectLocationAgentImportCall), [*locations agent intents batch delete*](api::ProjectLocationAgentIntentBatchDeleteCall), [*locations agent intents batch update*](api::ProjectLocationAgentIntentBatchUpdateCall), [*locations agent intents create*](api::ProjectLocationAgentIntentCreateCall), [*locations agent intents delete*](api::ProjectLocationAgentIntentDeleteCall), [*locations agent intents get*](api::ProjectLocationAgentIntentGetCall), [*locations agent intents list*](api::ProjectLocationAgentIntentListCall), [*locations agent intents patch*](api::ProjectLocationAgentIntentPatchCall), [*locations agent restore*](api::ProjectLocationAgentRestoreCall), [*locations agent search*](api::ProjectLocationAgentSearchCall), [*locations agent sessions contexts create*](api::ProjectLocationAgentSessionContextCreateCall), [*locations agent sessions contexts delete*](api::ProjectLocationAgentSessionContextDeleteCall), [*locations agent sessions contexts get*](api::ProjectLocationAgentSessionContextGetCall), [*locations agent sessions contexts list*](api::ProjectLocationAgentSessionContextListCall), [*locations agent sessions contexts patch*](api::ProjectLocationAgentSessionContextPatchCall), [*locations agent sessions delete contexts*](api::ProjectLocationAgentSessionDeleteContextCall), [*locations agent sessions detect intent*](api::ProjectLocationAgentSessionDetectIntentCall), [*locations agent sessions entity types create*](api::ProjectLocationAgentSessionEntityTypeCreateCall), [*locations agent sessions entity types delete*](api::ProjectLocationAgentSessionEntityTypeDeleteCall), [*locations agent sessions entity types get*](api::ProjectLocationAgentSessionEntityTypeGetCall), [*locations agent sessions entity types list*](api::ProjectLocationAgentSessionEntityTypeListCall), [*locations agent sessions entity types patch*](api::ProjectLocationAgentSessionEntityTypePatchCall), [*locations agent train*](api::ProjectLocationAgentTrainCall), [*locations agent update fulfillment*](api::ProjectLocationAgentUpdateFulfillmentCall), [*locations agent versions create*](api::ProjectLocationAgentVersionCreateCall), [*locations agent versions delete*](api::ProjectLocationAgentVersionDeleteCall), [*locations agent versions get*](api::ProjectLocationAgentVersionGetCall), [*locations agent versions list*](api::ProjectLocationAgentVersionListCall), [*locations agent versions patch*](api::ProjectLocationAgentVersionPatchCall), [*locations answer records list*](api::ProjectLocationAnswerRecordListCall), [*locations answer records patch*](api::ProjectLocationAnswerRecordPatchCall), [*locations conversation datasets create*](api::ProjectLocationConversationDatasetCreateCall), [*locations conversation datasets delete*](api::ProjectLocationConversationDatasetDeleteCall), [*locations conversation datasets get*](api::ProjectLocationConversationDatasetGetCall), [*locations conversation datasets import conversation data*](api::ProjectLocationConversationDatasetImportConversationDataCall), [*locations conversation datasets list*](api::ProjectLocationConversationDatasetListCall), [*locations conversation models create*](api::ProjectLocationConversationModelCreateCall), [*locations conversation models delete*](api::ProjectLocationConversationModelDeleteCall), [*locations conversation models deploy*](api::ProjectLocationConversationModelDeployCall), [*locations conversation models evaluations create*](api::ProjectLocationConversationModelEvaluationCreateCall), [*locations conversation models evaluations get*](api::ProjectLocationConversationModelEvaluationGetCall), [*locations conversation models evaluations list*](api::ProjectLocationConversationModelEvaluationListCall), [*locations conversation models get*](api::ProjectLocationConversationModelGetCall), [*locations conversation models list*](api::ProjectLocationConversationModelListCall), [*locations conversation models undeploy*](api::ProjectLocationConversationModelUndeployCall), [*locations conversation profiles clear suggestion feature config*](api::ProjectLocationConversationProfileClearSuggestionFeatureConfigCall), [*locations conversation profiles create*](api::ProjectLocationConversationProfileCreateCall), [*locations conversation profiles delete*](api::ProjectLocationConversationProfileDeleteCall), [*locations conversation profiles get*](api::ProjectLocationConversationProfileGetCall), [*locations conversation profiles list*](api::ProjectLocationConversationProfileListCall), [*locations conversation profiles patch*](api::ProjectLocationConversationProfilePatchCall), [*locations conversation profiles set suggestion feature config*](api::ProjectLocationConversationProfileSetSuggestionFeatureConfigCall), [*locations conversations complete*](api::ProjectLocationConversationCompleteCall), [*locations conversations create*](api::ProjectLocationConversationCreateCall), [*locations conversations get*](api::ProjectLocationConversationGetCall), [*locations conversations list*](api::ProjectLocationConversationListCall), [*locations conversations messages list*](api::ProjectLocationConversationMessageListCall), [*locations conversations participants analyze content*](api::ProjectLocationConversationParticipantAnalyzeContentCall), [*locations conversations participants create*](api::ProjectLocationConversationParticipantCreateCall), [*locations conversations participants get*](api::ProjectLocationConversationParticipantGetCall), [*locations conversations participants list*](api::ProjectLocationConversationParticipantListCall), [*locations conversations participants patch*](api::ProjectLocationConversationParticipantPatchCall), [*locations conversations participants suggestions suggest articles*](api::ProjectLocationConversationParticipantSuggestionSuggestArticleCall), [*locations conversations participants suggestions suggest faq answers*](api::ProjectLocationConversationParticipantSuggestionSuggestFaqAnswerCall), [*locations conversations participants suggestions suggest smart replies*](api::ProjectLocationConversationParticipantSuggestionSuggestSmartReplyCall), [*locations conversations suggestions search knowledge*](api::ProjectLocationConversationSuggestionSearchKnowledgeCall), [*locations conversations suggestions suggest conversation summary*](api::ProjectLocationConversationSuggestionSuggestConversationSummaryCall), [*locations delete agent*](api::ProjectLocationDeleteAgentCall), [*locations get*](api::ProjectLocationGetCall), [*locations get agent*](api::ProjectLocationGetAgentCall), [*locations knowledge bases create*](api::ProjectLocationKnowledgeBaseCreateCall), [*locations knowledge bases delete*](api::ProjectLocationKnowledgeBaseDeleteCall), [*locations knowledge bases documents create*](api::ProjectLocationKnowledgeBaseDocumentCreateCall), [*locations knowledge bases documents delete*](api::ProjectLocationKnowledgeBaseDocumentDeleteCall), [*locations knowledge bases documents export*](api::ProjectLocationKnowledgeBaseDocumentExportCall), [*locations knowledge bases documents get*](api::ProjectLocationKnowledgeBaseDocumentGetCall), [*locations knowledge bases documents import*](api::ProjectLocationKnowledgeBaseDocumentImportCall), [*locations knowledge bases documents list*](api::ProjectLocationKnowledgeBaseDocumentListCall), [*locations knowledge bases documents patch*](api::ProjectLocationKnowledgeBaseDocumentPatchCall), [*locations knowledge bases documents reload*](api::ProjectLocationKnowledgeBaseDocumentReloadCall), [*locations knowledge bases get*](api::ProjectLocationKnowledgeBaseGetCall), [*locations knowledge bases list*](api::ProjectLocationKnowledgeBaseListCall), [*locations knowledge bases patch*](api::ProjectLocationKnowledgeBasePatchCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations set agent*](api::ProjectLocationSetAgentCall), [*locations suggestions generate stateless summary*](api::ProjectLocationSuggestionGenerateStatelessSummaryCall), [*locations suggestions search knowledge*](api::ProjectLocationSuggestionSearchKnowledgeCall), [*operations cancel*](api::ProjectOperationCancelCall), [*operations get*](api::ProjectOperationGetCall), [*operations list*](api::ProjectOperationListCall), [*set agent*](api::ProjectSetAgentCall), [*suggestions generate stateless summary*](api::ProjectSuggestionGenerateStatelessSummaryCall) and [*suggestions search knowledge*](api::ProjectSuggestionSearchKnowledgeCall) @@ -106,8 +106,8 @@ //! let r = hub.projects().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -136,12 +136,12 @@ //! use std::default::Default; //! use dialogflow2::{Dialogflow, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -183,10 +183,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -196,25 +196,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dialogflow2_beta1/src/lib.rs b/gen/dialogflow2_beta1/src/lib.rs index b01f04949d..4a1f028997 100644 --- a/gen/dialogflow2_beta1/src/lib.rs +++ b/gen/dialogflow2_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dialogflow2_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dialogflow) ... +//! Handle the following *Resources* with ease from the central [hub](Dialogflow) ... //! //! * projects //! * [*agent entity types batch delete*](api::ProjectAgentEntityTypeBatchDeleteCall), [*agent entity types batch update*](api::ProjectAgentEntityTypeBatchUpdateCall), [*agent entity types create*](api::ProjectAgentEntityTypeCreateCall), [*agent entity types delete*](api::ProjectAgentEntityTypeDeleteCall), [*agent entity types entities batch create*](api::ProjectAgentEntityTypeEntityBatchCreateCall), [*agent entity types entities batch delete*](api::ProjectAgentEntityTypeEntityBatchDeleteCall), [*agent entity types entities batch update*](api::ProjectAgentEntityTypeEntityBatchUpdateCall), [*agent entity types get*](api::ProjectAgentEntityTypeGetCall), [*agent entity types list*](api::ProjectAgentEntityTypeListCall), [*agent entity types patch*](api::ProjectAgentEntityTypePatchCall), [*agent environments create*](api::ProjectAgentEnvironmentCreateCall), [*agent environments delete*](api::ProjectAgentEnvironmentDeleteCall), [*agent environments get*](api::ProjectAgentEnvironmentGetCall), [*agent environments get history*](api::ProjectAgentEnvironmentGetHistoryCall), [*agent environments intents list*](api::ProjectAgentEnvironmentIntentListCall), [*agent environments list*](api::ProjectAgentEnvironmentListCall), [*agent environments patch*](api::ProjectAgentEnvironmentPatchCall), [*agent environments users sessions contexts create*](api::ProjectAgentEnvironmentUserSessionContextCreateCall), [*agent environments users sessions contexts delete*](api::ProjectAgentEnvironmentUserSessionContextDeleteCall), [*agent environments users sessions contexts get*](api::ProjectAgentEnvironmentUserSessionContextGetCall), [*agent environments users sessions contexts list*](api::ProjectAgentEnvironmentUserSessionContextListCall), [*agent environments users sessions contexts patch*](api::ProjectAgentEnvironmentUserSessionContextPatchCall), [*agent environments users sessions delete contexts*](api::ProjectAgentEnvironmentUserSessionDeleteContextCall), [*agent environments users sessions detect intent*](api::ProjectAgentEnvironmentUserSessionDetectIntentCall), [*agent environments users sessions entity types create*](api::ProjectAgentEnvironmentUserSessionEntityTypeCreateCall), [*agent environments users sessions entity types delete*](api::ProjectAgentEnvironmentUserSessionEntityTypeDeleteCall), [*agent environments users sessions entity types get*](api::ProjectAgentEnvironmentUserSessionEntityTypeGetCall), [*agent environments users sessions entity types list*](api::ProjectAgentEnvironmentUserSessionEntityTypeListCall), [*agent environments users sessions entity types patch*](api::ProjectAgentEnvironmentUserSessionEntityTypePatchCall), [*agent export*](api::ProjectAgentExportCall), [*agent get fulfillment*](api::ProjectAgentGetFulfillmentCall), [*agent get validation result*](api::ProjectAgentGetValidationResultCall), [*agent import*](api::ProjectAgentImportCall), [*agent intents batch delete*](api::ProjectAgentIntentBatchDeleteCall), [*agent intents batch update*](api::ProjectAgentIntentBatchUpdateCall), [*agent intents create*](api::ProjectAgentIntentCreateCall), [*agent intents delete*](api::ProjectAgentIntentDeleteCall), [*agent intents get*](api::ProjectAgentIntentGetCall), [*agent intents list*](api::ProjectAgentIntentListCall), [*agent intents patch*](api::ProjectAgentIntentPatchCall), [*agent knowledge bases create*](api::ProjectAgentKnowledgeBaseCreateCall), [*agent knowledge bases delete*](api::ProjectAgentKnowledgeBaseDeleteCall), [*agent knowledge bases documents create*](api::ProjectAgentKnowledgeBaseDocumentCreateCall), [*agent knowledge bases documents delete*](api::ProjectAgentKnowledgeBaseDocumentDeleteCall), [*agent knowledge bases documents get*](api::ProjectAgentKnowledgeBaseDocumentGetCall), [*agent knowledge bases documents list*](api::ProjectAgentKnowledgeBaseDocumentListCall), [*agent knowledge bases documents patch*](api::ProjectAgentKnowledgeBaseDocumentPatchCall), [*agent knowledge bases documents reload*](api::ProjectAgentKnowledgeBaseDocumentReloadCall), [*agent knowledge bases get*](api::ProjectAgentKnowledgeBaseGetCall), [*agent knowledge bases list*](api::ProjectAgentKnowledgeBaseListCall), [*agent knowledge bases patch*](api::ProjectAgentKnowledgeBasePatchCall), [*agent restore*](api::ProjectAgentRestoreCall), [*agent search*](api::ProjectAgentSearchCall), [*agent sessions contexts create*](api::ProjectAgentSessionContextCreateCall), [*agent sessions contexts delete*](api::ProjectAgentSessionContextDeleteCall), [*agent sessions contexts get*](api::ProjectAgentSessionContextGetCall), [*agent sessions contexts list*](api::ProjectAgentSessionContextListCall), [*agent sessions contexts patch*](api::ProjectAgentSessionContextPatchCall), [*agent sessions delete contexts*](api::ProjectAgentSessionDeleteContextCall), [*agent sessions detect intent*](api::ProjectAgentSessionDetectIntentCall), [*agent sessions entity types create*](api::ProjectAgentSessionEntityTypeCreateCall), [*agent sessions entity types delete*](api::ProjectAgentSessionEntityTypeDeleteCall), [*agent sessions entity types get*](api::ProjectAgentSessionEntityTypeGetCall), [*agent sessions entity types list*](api::ProjectAgentSessionEntityTypeListCall), [*agent sessions entity types patch*](api::ProjectAgentSessionEntityTypePatchCall), [*agent train*](api::ProjectAgentTrainCall), [*agent update fulfillment*](api::ProjectAgentUpdateFulfillmentCall), [*agent versions create*](api::ProjectAgentVersionCreateCall), [*agent versions delete*](api::ProjectAgentVersionDeleteCall), [*agent versions get*](api::ProjectAgentVersionGetCall), [*agent versions list*](api::ProjectAgentVersionListCall), [*agent versions patch*](api::ProjectAgentVersionPatchCall), [*answer records get*](api::ProjectAnswerRecordGetCall), [*answer records list*](api::ProjectAnswerRecordListCall), [*answer records patch*](api::ProjectAnswerRecordPatchCall), [*conversation profiles clear suggestion feature config*](api::ProjectConversationProfileClearSuggestionFeatureConfigCall), [*conversation profiles create*](api::ProjectConversationProfileCreateCall), [*conversation profiles delete*](api::ProjectConversationProfileDeleteCall), [*conversation profiles get*](api::ProjectConversationProfileGetCall), [*conversation profiles list*](api::ProjectConversationProfileListCall), [*conversation profiles patch*](api::ProjectConversationProfilePatchCall), [*conversation profiles set suggestion feature config*](api::ProjectConversationProfileSetSuggestionFeatureConfigCall), [*conversations complete*](api::ProjectConversationCompleteCall), [*conversations create*](api::ProjectConversationCreateCall), [*conversations get*](api::ProjectConversationGetCall), [*conversations list*](api::ProjectConversationListCall), [*conversations messages batch create*](api::ProjectConversationMessageBatchCreateCall), [*conversations messages list*](api::ProjectConversationMessageListCall), [*conversations participants analyze content*](api::ProjectConversationParticipantAnalyzeContentCall), [*conversations participants create*](api::ProjectConversationParticipantCreateCall), [*conversations participants get*](api::ProjectConversationParticipantGetCall), [*conversations participants list*](api::ProjectConversationParticipantListCall), [*conversations participants patch*](api::ProjectConversationParticipantPatchCall), [*conversations participants suggestions compile*](api::ProjectConversationParticipantSuggestionCompileCall), [*conversations participants suggestions list*](api::ProjectConversationParticipantSuggestionListCall), [*conversations participants suggestions suggest articles*](api::ProjectConversationParticipantSuggestionSuggestArticleCall), [*conversations participants suggestions suggest faq answers*](api::ProjectConversationParticipantSuggestionSuggestFaqAnswerCall), [*conversations participants suggestions suggest smart replies*](api::ProjectConversationParticipantSuggestionSuggestSmartReplyCall), [*conversations suggestions search knowledge*](api::ProjectConversationSuggestionSearchKnowledgeCall), [*conversations suggestions suggest conversation summary*](api::ProjectConversationSuggestionSuggestConversationSummaryCall), [*delete agent*](api::ProjectDeleteAgentCall), [*get agent*](api::ProjectGetAgentCall), [*knowledge bases create*](api::ProjectKnowledgeBaseCreateCall), [*knowledge bases delete*](api::ProjectKnowledgeBaseDeleteCall), [*knowledge bases documents create*](api::ProjectKnowledgeBaseDocumentCreateCall), [*knowledge bases documents delete*](api::ProjectKnowledgeBaseDocumentDeleteCall), [*knowledge bases documents get*](api::ProjectKnowledgeBaseDocumentGetCall), [*knowledge bases documents import*](api::ProjectKnowledgeBaseDocumentImportCall), [*knowledge bases documents list*](api::ProjectKnowledgeBaseDocumentListCall), [*knowledge bases documents patch*](api::ProjectKnowledgeBaseDocumentPatchCall), [*knowledge bases documents reload*](api::ProjectKnowledgeBaseDocumentReloadCall), [*knowledge bases get*](api::ProjectKnowledgeBaseGetCall), [*knowledge bases list*](api::ProjectKnowledgeBaseListCall), [*knowledge bases patch*](api::ProjectKnowledgeBasePatchCall), [*locations agent entity types batch delete*](api::ProjectLocationAgentEntityTypeBatchDeleteCall), [*locations agent entity types batch update*](api::ProjectLocationAgentEntityTypeBatchUpdateCall), [*locations agent entity types create*](api::ProjectLocationAgentEntityTypeCreateCall), [*locations agent entity types delete*](api::ProjectLocationAgentEntityTypeDeleteCall), [*locations agent entity types entities batch create*](api::ProjectLocationAgentEntityTypeEntityBatchCreateCall), [*locations agent entity types entities batch delete*](api::ProjectLocationAgentEntityTypeEntityBatchDeleteCall), [*locations agent entity types entities batch update*](api::ProjectLocationAgentEntityTypeEntityBatchUpdateCall), [*locations agent entity types get*](api::ProjectLocationAgentEntityTypeGetCall), [*locations agent entity types list*](api::ProjectLocationAgentEntityTypeListCall), [*locations agent entity types patch*](api::ProjectLocationAgentEntityTypePatchCall), [*locations agent environments create*](api::ProjectLocationAgentEnvironmentCreateCall), [*locations agent environments delete*](api::ProjectLocationAgentEnvironmentDeleteCall), [*locations agent environments get*](api::ProjectLocationAgentEnvironmentGetCall), [*locations agent environments get history*](api::ProjectLocationAgentEnvironmentGetHistoryCall), [*locations agent environments intents list*](api::ProjectLocationAgentEnvironmentIntentListCall), [*locations agent environments list*](api::ProjectLocationAgentEnvironmentListCall), [*locations agent environments patch*](api::ProjectLocationAgentEnvironmentPatchCall), [*locations agent environments users sessions contexts create*](api::ProjectLocationAgentEnvironmentUserSessionContextCreateCall), [*locations agent environments users sessions contexts delete*](api::ProjectLocationAgentEnvironmentUserSessionContextDeleteCall), [*locations agent environments users sessions contexts get*](api::ProjectLocationAgentEnvironmentUserSessionContextGetCall), [*locations agent environments users sessions contexts list*](api::ProjectLocationAgentEnvironmentUserSessionContextListCall), [*locations agent environments users sessions contexts patch*](api::ProjectLocationAgentEnvironmentUserSessionContextPatchCall), [*locations agent environments users sessions delete contexts*](api::ProjectLocationAgentEnvironmentUserSessionDeleteContextCall), [*locations agent environments users sessions detect intent*](api::ProjectLocationAgentEnvironmentUserSessionDetectIntentCall), [*locations agent environments users sessions entity types create*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypeCreateCall), [*locations agent environments users sessions entity types delete*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypeDeleteCall), [*locations agent environments users sessions entity types get*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypeGetCall), [*locations agent environments users sessions entity types list*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypeListCall), [*locations agent environments users sessions entity types patch*](api::ProjectLocationAgentEnvironmentUserSessionEntityTypePatchCall), [*locations agent export*](api::ProjectLocationAgentExportCall), [*locations agent get fulfillment*](api::ProjectLocationAgentGetFulfillmentCall), [*locations agent get validation result*](api::ProjectLocationAgentGetValidationResultCall), [*locations agent import*](api::ProjectLocationAgentImportCall), [*locations agent intents batch delete*](api::ProjectLocationAgentIntentBatchDeleteCall), [*locations agent intents batch update*](api::ProjectLocationAgentIntentBatchUpdateCall), [*locations agent intents create*](api::ProjectLocationAgentIntentCreateCall), [*locations agent intents delete*](api::ProjectLocationAgentIntentDeleteCall), [*locations agent intents get*](api::ProjectLocationAgentIntentGetCall), [*locations agent intents list*](api::ProjectLocationAgentIntentListCall), [*locations agent intents patch*](api::ProjectLocationAgentIntentPatchCall), [*locations agent restore*](api::ProjectLocationAgentRestoreCall), [*locations agent search*](api::ProjectLocationAgentSearchCall), [*locations agent sessions contexts create*](api::ProjectLocationAgentSessionContextCreateCall), [*locations agent sessions contexts delete*](api::ProjectLocationAgentSessionContextDeleteCall), [*locations agent sessions contexts get*](api::ProjectLocationAgentSessionContextGetCall), [*locations agent sessions contexts list*](api::ProjectLocationAgentSessionContextListCall), [*locations agent sessions contexts patch*](api::ProjectLocationAgentSessionContextPatchCall), [*locations agent sessions delete contexts*](api::ProjectLocationAgentSessionDeleteContextCall), [*locations agent sessions detect intent*](api::ProjectLocationAgentSessionDetectIntentCall), [*locations agent sessions entity types create*](api::ProjectLocationAgentSessionEntityTypeCreateCall), [*locations agent sessions entity types delete*](api::ProjectLocationAgentSessionEntityTypeDeleteCall), [*locations agent sessions entity types get*](api::ProjectLocationAgentSessionEntityTypeGetCall), [*locations agent sessions entity types list*](api::ProjectLocationAgentSessionEntityTypeListCall), [*locations agent sessions entity types patch*](api::ProjectLocationAgentSessionEntityTypePatchCall), [*locations agent train*](api::ProjectLocationAgentTrainCall), [*locations agent update fulfillment*](api::ProjectLocationAgentUpdateFulfillmentCall), [*locations agent versions create*](api::ProjectLocationAgentVersionCreateCall), [*locations agent versions delete*](api::ProjectLocationAgentVersionDeleteCall), [*locations agent versions get*](api::ProjectLocationAgentVersionGetCall), [*locations agent versions list*](api::ProjectLocationAgentVersionListCall), [*locations agent versions patch*](api::ProjectLocationAgentVersionPatchCall), [*locations answer records get*](api::ProjectLocationAnswerRecordGetCall), [*locations answer records list*](api::ProjectLocationAnswerRecordListCall), [*locations answer records patch*](api::ProjectLocationAnswerRecordPatchCall), [*locations conversation profiles clear suggestion feature config*](api::ProjectLocationConversationProfileClearSuggestionFeatureConfigCall), [*locations conversation profiles create*](api::ProjectLocationConversationProfileCreateCall), [*locations conversation profiles delete*](api::ProjectLocationConversationProfileDeleteCall), [*locations conversation profiles get*](api::ProjectLocationConversationProfileGetCall), [*locations conversation profiles list*](api::ProjectLocationConversationProfileListCall), [*locations conversation profiles patch*](api::ProjectLocationConversationProfilePatchCall), [*locations conversation profiles set suggestion feature config*](api::ProjectLocationConversationProfileSetSuggestionFeatureConfigCall), [*locations conversations complete*](api::ProjectLocationConversationCompleteCall), [*locations conversations create*](api::ProjectLocationConversationCreateCall), [*locations conversations get*](api::ProjectLocationConversationGetCall), [*locations conversations list*](api::ProjectLocationConversationListCall), [*locations conversations messages batch create*](api::ProjectLocationConversationMessageBatchCreateCall), [*locations conversations messages list*](api::ProjectLocationConversationMessageListCall), [*locations conversations participants analyze content*](api::ProjectLocationConversationParticipantAnalyzeContentCall), [*locations conversations participants create*](api::ProjectLocationConversationParticipantCreateCall), [*locations conversations participants get*](api::ProjectLocationConversationParticipantGetCall), [*locations conversations participants list*](api::ProjectLocationConversationParticipantListCall), [*locations conversations participants patch*](api::ProjectLocationConversationParticipantPatchCall), [*locations conversations participants suggestions suggest articles*](api::ProjectLocationConversationParticipantSuggestionSuggestArticleCall), [*locations conversations participants suggestions suggest faq answers*](api::ProjectLocationConversationParticipantSuggestionSuggestFaqAnswerCall), [*locations conversations participants suggestions suggest smart replies*](api::ProjectLocationConversationParticipantSuggestionSuggestSmartReplyCall), [*locations conversations suggestions search knowledge*](api::ProjectLocationConversationSuggestionSearchKnowledgeCall), [*locations conversations suggestions suggest conversation summary*](api::ProjectLocationConversationSuggestionSuggestConversationSummaryCall), [*locations delete agent*](api::ProjectLocationDeleteAgentCall), [*locations get*](api::ProjectLocationGetCall), [*locations get agent*](api::ProjectLocationGetAgentCall), [*locations knowledge bases create*](api::ProjectLocationKnowledgeBaseCreateCall), [*locations knowledge bases delete*](api::ProjectLocationKnowledgeBaseDeleteCall), [*locations knowledge bases documents create*](api::ProjectLocationKnowledgeBaseDocumentCreateCall), [*locations knowledge bases documents delete*](api::ProjectLocationKnowledgeBaseDocumentDeleteCall), [*locations knowledge bases documents get*](api::ProjectLocationKnowledgeBaseDocumentGetCall), [*locations knowledge bases documents import*](api::ProjectLocationKnowledgeBaseDocumentImportCall), [*locations knowledge bases documents list*](api::ProjectLocationKnowledgeBaseDocumentListCall), [*locations knowledge bases documents patch*](api::ProjectLocationKnowledgeBaseDocumentPatchCall), [*locations knowledge bases documents reload*](api::ProjectLocationKnowledgeBaseDocumentReloadCall), [*locations knowledge bases get*](api::ProjectLocationKnowledgeBaseGetCall), [*locations knowledge bases list*](api::ProjectLocationKnowledgeBaseListCall), [*locations knowledge bases patch*](api::ProjectLocationKnowledgeBasePatchCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations set agent*](api::ProjectLocationSetAgentCall), [*locations suggestions generate stateless summary*](api::ProjectLocationSuggestionGenerateStatelessSummaryCall), [*locations suggestions search knowledge*](api::ProjectLocationSuggestionSearchKnowledgeCall), [*operations cancel*](api::ProjectOperationCancelCall), [*operations get*](api::ProjectOperationGetCall), [*operations list*](api::ProjectOperationListCall), [*set agent*](api::ProjectSetAgentCall), [*suggestions generate stateless summary*](api::ProjectSuggestionGenerateStatelessSummaryCall) and [*suggestions search knowledge*](api::ProjectSuggestionSearchKnowledgeCall) @@ -91,8 +91,8 @@ //! let r = hub.projects().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -121,12 +121,12 @@ //! use std::default::Default; //! use dialogflow2_beta1::{Dialogflow, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -168,10 +168,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -181,25 +181,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dialogflow3/src/lib.rs b/gen/dialogflow3/src/lib.rs index 6362d4ed32..c6e200981b 100644 --- a/gen/dialogflow3/src/lib.rs +++ b/gen/dialogflow3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dialogflow3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dialogflow) ... +//! Handle the following *Resources* with ease from the central [hub](Dialogflow) ... //! //! * projects //! * [*locations agents changelogs get*](api::ProjectLocationAgentChangelogGetCall), [*locations agents changelogs list*](api::ProjectLocationAgentChangelogListCall), [*locations agents create*](api::ProjectLocationAgentCreateCall), [*locations agents delete*](api::ProjectLocationAgentDeleteCall), [*locations agents entity types create*](api::ProjectLocationAgentEntityTypeCreateCall), [*locations agents entity types delete*](api::ProjectLocationAgentEntityTypeDeleteCall), [*locations agents entity types export*](api::ProjectLocationAgentEntityTypeExportCall), [*locations agents entity types get*](api::ProjectLocationAgentEntityTypeGetCall), [*locations agents entity types import*](api::ProjectLocationAgentEntityTypeImportCall), [*locations agents entity types list*](api::ProjectLocationAgentEntityTypeListCall), [*locations agents entity types patch*](api::ProjectLocationAgentEntityTypePatchCall), [*locations agents environments continuous test results list*](api::ProjectLocationAgentEnvironmentContinuousTestResultListCall), [*locations agents environments create*](api::ProjectLocationAgentEnvironmentCreateCall), [*locations agents environments delete*](api::ProjectLocationAgentEnvironmentDeleteCall), [*locations agents environments deploy flow*](api::ProjectLocationAgentEnvironmentDeployFlowCall), [*locations agents environments deployments get*](api::ProjectLocationAgentEnvironmentDeploymentGetCall), [*locations agents environments deployments list*](api::ProjectLocationAgentEnvironmentDeploymentListCall), [*locations agents environments experiments create*](api::ProjectLocationAgentEnvironmentExperimentCreateCall), [*locations agents environments experiments delete*](api::ProjectLocationAgentEnvironmentExperimentDeleteCall), [*locations agents environments experiments get*](api::ProjectLocationAgentEnvironmentExperimentGetCall), [*locations agents environments experiments list*](api::ProjectLocationAgentEnvironmentExperimentListCall), [*locations agents environments experiments patch*](api::ProjectLocationAgentEnvironmentExperimentPatchCall), [*locations agents environments experiments start*](api::ProjectLocationAgentEnvironmentExperimentStartCall), [*locations agents environments experiments stop*](api::ProjectLocationAgentEnvironmentExperimentStopCall), [*locations agents environments get*](api::ProjectLocationAgentEnvironmentGetCall), [*locations agents environments list*](api::ProjectLocationAgentEnvironmentListCall), [*locations agents environments lookup environment history*](api::ProjectLocationAgentEnvironmentLookupEnvironmentHistoryCall), [*locations agents environments patch*](api::ProjectLocationAgentEnvironmentPatchCall), [*locations agents environments run continuous test*](api::ProjectLocationAgentEnvironmentRunContinuousTestCall), [*locations agents environments sessions detect intent*](api::ProjectLocationAgentEnvironmentSessionDetectIntentCall), [*locations agents environments sessions entity types create*](api::ProjectLocationAgentEnvironmentSessionEntityTypeCreateCall), [*locations agents environments sessions entity types delete*](api::ProjectLocationAgentEnvironmentSessionEntityTypeDeleteCall), [*locations agents environments sessions entity types get*](api::ProjectLocationAgentEnvironmentSessionEntityTypeGetCall), [*locations agents environments sessions entity types list*](api::ProjectLocationAgentEnvironmentSessionEntityTypeListCall), [*locations agents environments sessions entity types patch*](api::ProjectLocationAgentEnvironmentSessionEntityTypePatchCall), [*locations agents environments sessions fulfill intent*](api::ProjectLocationAgentEnvironmentSessionFulfillIntentCall), [*locations agents environments sessions match intent*](api::ProjectLocationAgentEnvironmentSessionMatchIntentCall), [*locations agents environments sessions server streaming detect intent*](api::ProjectLocationAgentEnvironmentSessionServerStreamingDetectIntentCall), [*locations agents export*](api::ProjectLocationAgentExportCall), [*locations agents flows create*](api::ProjectLocationAgentFlowCreateCall), [*locations agents flows delete*](api::ProjectLocationAgentFlowDeleteCall), [*locations agents flows export*](api::ProjectLocationAgentFlowExportCall), [*locations agents flows get*](api::ProjectLocationAgentFlowGetCall), [*locations agents flows get validation result*](api::ProjectLocationAgentFlowGetValidationResultCall), [*locations agents flows import*](api::ProjectLocationAgentFlowImportCall), [*locations agents flows list*](api::ProjectLocationAgentFlowListCall), [*locations agents flows pages create*](api::ProjectLocationAgentFlowPageCreateCall), [*locations agents flows pages delete*](api::ProjectLocationAgentFlowPageDeleteCall), [*locations agents flows pages get*](api::ProjectLocationAgentFlowPageGetCall), [*locations agents flows pages list*](api::ProjectLocationAgentFlowPageListCall), [*locations agents flows pages patch*](api::ProjectLocationAgentFlowPagePatchCall), [*locations agents flows patch*](api::ProjectLocationAgentFlowPatchCall), [*locations agents flows train*](api::ProjectLocationAgentFlowTrainCall), [*locations agents flows transition route groups create*](api::ProjectLocationAgentFlowTransitionRouteGroupCreateCall), [*locations agents flows transition route groups delete*](api::ProjectLocationAgentFlowTransitionRouteGroupDeleteCall), [*locations agents flows transition route groups get*](api::ProjectLocationAgentFlowTransitionRouteGroupGetCall), [*locations agents flows transition route groups list*](api::ProjectLocationAgentFlowTransitionRouteGroupListCall), [*locations agents flows transition route groups patch*](api::ProjectLocationAgentFlowTransitionRouteGroupPatchCall), [*locations agents flows validate*](api::ProjectLocationAgentFlowValidateCall), [*locations agents flows versions compare versions*](api::ProjectLocationAgentFlowVersionCompareVersionCall), [*locations agents flows versions create*](api::ProjectLocationAgentFlowVersionCreateCall), [*locations agents flows versions delete*](api::ProjectLocationAgentFlowVersionDeleteCall), [*locations agents flows versions get*](api::ProjectLocationAgentFlowVersionGetCall), [*locations agents flows versions list*](api::ProjectLocationAgentFlowVersionListCall), [*locations agents flows versions load*](api::ProjectLocationAgentFlowVersionLoadCall), [*locations agents flows versions patch*](api::ProjectLocationAgentFlowVersionPatchCall), [*locations agents generators create*](api::ProjectLocationAgentGeneratorCreateCall), [*locations agents generators delete*](api::ProjectLocationAgentGeneratorDeleteCall), [*locations agents generators get*](api::ProjectLocationAgentGeneratorGetCall), [*locations agents generators list*](api::ProjectLocationAgentGeneratorListCall), [*locations agents generators patch*](api::ProjectLocationAgentGeneratorPatchCall), [*locations agents get*](api::ProjectLocationAgentGetCall), [*locations agents get generative settings*](api::ProjectLocationAgentGetGenerativeSettingCall), [*locations agents get validation result*](api::ProjectLocationAgentGetValidationResultCall), [*locations agents intents create*](api::ProjectLocationAgentIntentCreateCall), [*locations agents intents delete*](api::ProjectLocationAgentIntentDeleteCall), [*locations agents intents export*](api::ProjectLocationAgentIntentExportCall), [*locations agents intents get*](api::ProjectLocationAgentIntentGetCall), [*locations agents intents import*](api::ProjectLocationAgentIntentImportCall), [*locations agents intents list*](api::ProjectLocationAgentIntentListCall), [*locations agents intents patch*](api::ProjectLocationAgentIntentPatchCall), [*locations agents list*](api::ProjectLocationAgentListCall), [*locations agents patch*](api::ProjectLocationAgentPatchCall), [*locations agents restore*](api::ProjectLocationAgentRestoreCall), [*locations agents sessions detect intent*](api::ProjectLocationAgentSessionDetectIntentCall), [*locations agents sessions entity types create*](api::ProjectLocationAgentSessionEntityTypeCreateCall), [*locations agents sessions entity types delete*](api::ProjectLocationAgentSessionEntityTypeDeleteCall), [*locations agents sessions entity types get*](api::ProjectLocationAgentSessionEntityTypeGetCall), [*locations agents sessions entity types list*](api::ProjectLocationAgentSessionEntityTypeListCall), [*locations agents sessions entity types patch*](api::ProjectLocationAgentSessionEntityTypePatchCall), [*locations agents sessions fulfill intent*](api::ProjectLocationAgentSessionFulfillIntentCall), [*locations agents sessions match intent*](api::ProjectLocationAgentSessionMatchIntentCall), [*locations agents sessions server streaming detect intent*](api::ProjectLocationAgentSessionServerStreamingDetectIntentCall), [*locations agents sessions submit answer feedback*](api::ProjectLocationAgentSessionSubmitAnswerFeedbackCall), [*locations agents test cases batch delete*](api::ProjectLocationAgentTestCaseBatchDeleteCall), [*locations agents test cases batch run*](api::ProjectLocationAgentTestCaseBatchRunCall), [*locations agents test cases calculate coverage*](api::ProjectLocationAgentTestCaseCalculateCoverageCall), [*locations agents test cases create*](api::ProjectLocationAgentTestCaseCreateCall), [*locations agents test cases export*](api::ProjectLocationAgentTestCaseExportCall), [*locations agents test cases get*](api::ProjectLocationAgentTestCaseGetCall), [*locations agents test cases import*](api::ProjectLocationAgentTestCaseImportCall), [*locations agents test cases list*](api::ProjectLocationAgentTestCaseListCall), [*locations agents test cases patch*](api::ProjectLocationAgentTestCasePatchCall), [*locations agents test cases results get*](api::ProjectLocationAgentTestCaseResultGetCall), [*locations agents test cases results list*](api::ProjectLocationAgentTestCaseResultListCall), [*locations agents test cases run*](api::ProjectLocationAgentTestCaseRunCall), [*locations agents transition route groups create*](api::ProjectLocationAgentTransitionRouteGroupCreateCall), [*locations agents transition route groups delete*](api::ProjectLocationAgentTransitionRouteGroupDeleteCall), [*locations agents transition route groups get*](api::ProjectLocationAgentTransitionRouteGroupGetCall), [*locations agents transition route groups list*](api::ProjectLocationAgentTransitionRouteGroupListCall), [*locations agents transition route groups patch*](api::ProjectLocationAgentTransitionRouteGroupPatchCall), [*locations agents update generative settings*](api::ProjectLocationAgentUpdateGenerativeSettingCall), [*locations agents validate*](api::ProjectLocationAgentValidateCall), [*locations agents webhooks create*](api::ProjectLocationAgentWebhookCreateCall), [*locations agents webhooks delete*](api::ProjectLocationAgentWebhookDeleteCall), [*locations agents webhooks get*](api::ProjectLocationAgentWebhookGetCall), [*locations agents webhooks list*](api::ProjectLocationAgentWebhookListCall), [*locations agents webhooks patch*](api::ProjectLocationAgentWebhookPatchCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations security settings create*](api::ProjectLocationSecuritySettingCreateCall), [*locations security settings delete*](api::ProjectLocationSecuritySettingDeleteCall), [*locations security settings get*](api::ProjectLocationSecuritySettingGetCall), [*locations security settings list*](api::ProjectLocationSecuritySettingListCall), [*locations security settings patch*](api::ProjectLocationSecuritySettingPatchCall), [*operations cancel*](api::ProjectOperationCancelCall), [*operations get*](api::ProjectOperationGetCall) and [*operations list*](api::ProjectOperationListCall) @@ -70,8 +70,8 @@ //! let r = hub.projects().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -100,12 +100,12 @@ //! use std::default::Default; //! use dialogflow3::{Dialogflow, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -147,10 +147,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -160,25 +160,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/digitalassetlinks1/src/api.rs b/gen/digitalassetlinks1/src/api.rs index 1eb0ea752b..ba05eb0657 100644 --- a/gen/digitalassetlinks1/src/api.rs +++ b/gen/digitalassetlinks1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use digitalassetlinks1::{Digitalassetlinks, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/digitalassetlinks1/src/lib.rs b/gen/digitalassetlinks1/src/lib.rs index 117e5d5c4f..41c3747352 100644 --- a/gen/digitalassetlinks1/src/lib.rs +++ b/gen/digitalassetlinks1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/digitalassetlinks1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Digitalassetlinks) ... +//! Handle the following *Resources* with ease from the central [hub](Digitalassetlinks) ... //! //! * assetlinks //! * [*bulk check*](api::AssetlinkBulkCheckCall) and [*check*](api::AssetlinkCheckCall) @@ -52,8 +52,8 @@ //! let r = hub.assetlinks().bulk_check(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use digitalassetlinks1::{Digitalassetlinks, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/discovery1/src/api.rs b/gen/discovery1/src/api.rs index 9aa9953739..e76265c534 100644 --- a/gen/discovery1/src/api.rs +++ b/gen/discovery1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use discovery1::{Discovery, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/discovery1/src/lib.rs b/gen/discovery1/src/lib.rs index 90b1413d64..e8fe10356e 100644 --- a/gen/discovery1/src/lib.rs +++ b/gen/discovery1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/discovery1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Discovery) ... +//! Handle the following *Resources* with ease from the central [hub](Discovery) ... //! //! * apis //! * [*get rest*](api::ApiGetRestCall) and [*list*](api::ApiListCall) @@ -50,8 +50,8 @@ //! let r = hub.apis().get_rest(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use discovery1::{Discovery, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -120,10 +120,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -133,25 +133,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/displayvideo1/src/lib.rs b/gen/displayvideo1/src/lib.rs index 5f2f14cf3d..cff7f89ce3 100644 --- a/gen/displayvideo1/src/lib.rs +++ b/gen/displayvideo1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/displayvideo1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DisplayVideo) ... +//! Handle the following *Resources* with ease from the central [hub](DisplayVideo) ... //! //! * [advertisers](api::Advertiser) //! * [*assets upload*](api::AdvertiserAssetUploadCall), [*audit*](api::AdvertiserAuditCall), [*bulk edit advertiser assigned targeting options*](api::AdvertiserBulkEditAdvertiserAssignedTargetingOptionCall), [*bulk list advertiser assigned targeting options*](api::AdvertiserBulkListAdvertiserAssignedTargetingOptionCall), [*campaigns bulk list campaign assigned targeting options*](api::AdvertiserCampaignBulkListCampaignAssignedTargetingOptionCall), [*campaigns create*](api::AdvertiserCampaignCreateCall), [*campaigns delete*](api::AdvertiserCampaignDeleteCall), [*campaigns get*](api::AdvertiserCampaignGetCall), [*campaigns list*](api::AdvertiserCampaignListCall), [*campaigns patch*](api::AdvertiserCampaignPatchCall), [*campaigns targeting types assigned targeting options get*](api::AdvertiserCampaignTargetingTypeAssignedTargetingOptionGetCall), [*campaigns targeting types assigned targeting options list*](api::AdvertiserCampaignTargetingTypeAssignedTargetingOptionListCall), [*channels create*](api::AdvertiserChannelCreateCall), [*channels get*](api::AdvertiserChannelGetCall), [*channels list*](api::AdvertiserChannelListCall), [*channels patch*](api::AdvertiserChannelPatchCall), [*channels sites bulk edit*](api::AdvertiserChannelSiteBulkEditCall), [*channels sites create*](api::AdvertiserChannelSiteCreateCall), [*channels sites delete*](api::AdvertiserChannelSiteDeleteCall), [*channels sites list*](api::AdvertiserChannelSiteListCall), [*channels sites replace*](api::AdvertiserChannelSiteReplaceCall), [*create*](api::AdvertiserCreateCall), [*creatives create*](api::AdvertiserCreativeCreateCall), [*creatives delete*](api::AdvertiserCreativeDeleteCall), [*creatives get*](api::AdvertiserCreativeGetCall), [*creatives list*](api::AdvertiserCreativeListCall), [*creatives patch*](api::AdvertiserCreativePatchCall), [*delete*](api::AdvertiserDeleteCall), [*get*](api::AdvertiserGetCall), [*insertion orders bulk list insertion order assigned targeting options*](api::AdvertiserInsertionOrderBulkListInsertionOrderAssignedTargetingOptionCall), [*insertion orders create*](api::AdvertiserInsertionOrderCreateCall), [*insertion orders delete*](api::AdvertiserInsertionOrderDeleteCall), [*insertion orders get*](api::AdvertiserInsertionOrderGetCall), [*insertion orders list*](api::AdvertiserInsertionOrderListCall), [*insertion orders patch*](api::AdvertiserInsertionOrderPatchCall), [*insertion orders targeting types assigned targeting options get*](api::AdvertiserInsertionOrderTargetingTypeAssignedTargetingOptionGetCall), [*insertion orders targeting types assigned targeting options list*](api::AdvertiserInsertionOrderTargetingTypeAssignedTargetingOptionListCall), [*invoices list*](api::AdvertiserInvoiceListCall), [*invoices lookup invoice currency*](api::AdvertiserInvoiceLookupInvoiceCurrencyCall), [*line items bulk edit line item assigned targeting options*](api::AdvertiserLineItemBulkEditLineItemAssignedTargetingOptionCall), [*line items bulk list line item assigned targeting options*](api::AdvertiserLineItemBulkListLineItemAssignedTargetingOptionCall), [*line items create*](api::AdvertiserLineItemCreateCall), [*line items delete*](api::AdvertiserLineItemDeleteCall), [*line items generate default*](api::AdvertiserLineItemGenerateDefaultCall), [*line items get*](api::AdvertiserLineItemGetCall), [*line items list*](api::AdvertiserLineItemListCall), [*line items patch*](api::AdvertiserLineItemPatchCall), [*line items targeting types assigned targeting options create*](api::AdvertiserLineItemTargetingTypeAssignedTargetingOptionCreateCall), [*line items targeting types assigned targeting options delete*](api::AdvertiserLineItemTargetingTypeAssignedTargetingOptionDeleteCall), [*line items targeting types assigned targeting options get*](api::AdvertiserLineItemTargetingTypeAssignedTargetingOptionGetCall), [*line items targeting types assigned targeting options list*](api::AdvertiserLineItemTargetingTypeAssignedTargetingOptionListCall), [*list*](api::AdvertiserListCall), [*location lists assigned locations bulk edit*](api::AdvertiserLocationListAssignedLocationBulkEditCall), [*location lists assigned locations create*](api::AdvertiserLocationListAssignedLocationCreateCall), [*location lists assigned locations delete*](api::AdvertiserLocationListAssignedLocationDeleteCall), [*location lists assigned locations list*](api::AdvertiserLocationListAssignedLocationListCall), [*location lists create*](api::AdvertiserLocationListCreateCall), [*location lists get*](api::AdvertiserLocationListGetCall), [*location lists list*](api::AdvertiserLocationListListCall), [*location lists patch*](api::AdvertiserLocationListPatchCall), [*manual triggers activate*](api::AdvertiserManualTriggerActivateCall), [*manual triggers create*](api::AdvertiserManualTriggerCreateCall), [*manual triggers deactivate*](api::AdvertiserManualTriggerDeactivateCall), [*manual triggers get*](api::AdvertiserManualTriggerGetCall), [*manual triggers list*](api::AdvertiserManualTriggerListCall), [*manual triggers patch*](api::AdvertiserManualTriggerPatchCall), [*negative keyword lists create*](api::AdvertiserNegativeKeywordListCreateCall), [*negative keyword lists delete*](api::AdvertiserNegativeKeywordListDeleteCall), [*negative keyword lists get*](api::AdvertiserNegativeKeywordListGetCall), [*negative keyword lists list*](api::AdvertiserNegativeKeywordListListCall), [*negative keyword lists negative keywords bulk edit*](api::AdvertiserNegativeKeywordListNegativeKeywordBulkEditCall), [*negative keyword lists negative keywords create*](api::AdvertiserNegativeKeywordListNegativeKeywordCreateCall), [*negative keyword lists negative keywords delete*](api::AdvertiserNegativeKeywordListNegativeKeywordDeleteCall), [*negative keyword lists negative keywords list*](api::AdvertiserNegativeKeywordListNegativeKeywordListCall), [*negative keyword lists negative keywords replace*](api::AdvertiserNegativeKeywordListNegativeKeywordReplaceCall), [*negative keyword lists patch*](api::AdvertiserNegativeKeywordListPatchCall), [*patch*](api::AdvertiserPatchCall), [*targeting types assigned targeting options create*](api::AdvertiserTargetingTypeAssignedTargetingOptionCreateCall), [*targeting types assigned targeting options delete*](api::AdvertiserTargetingTypeAssignedTargetingOptionDeleteCall), [*targeting types assigned targeting options get*](api::AdvertiserTargetingTypeAssignedTargetingOptionGetCall) and [*targeting types assigned targeting options list*](api::AdvertiserTargetingTypeAssignedTargetingOptionListCall) @@ -167,8 +167,8 @@ //! let r = hub.advertisers().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -196,12 +196,12 @@ //! use std::default::Default; //! use displayvideo1::{DisplayVideo, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -241,10 +241,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -254,25 +254,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dlp2/src/lib.rs b/gen/dlp2/src/lib.rs index a2754ff476..f405c2e5d6 100644 --- a/gen/dlp2/src/lib.rs +++ b/gen/dlp2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dlp2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DLP) ... +//! Handle the following *Resources* with ease from the central [hub](DLP) ... //! //! * info types //! * [*list*](api::InfoTypeListCall) @@ -77,8 +77,8 @@ //! let r = hub.projects().stored_info_types_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -107,12 +107,12 @@ //! use std::default::Default; //! use dlp2::{DLP, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -153,10 +153,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -166,25 +166,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dlp2_beta1/src/lib.rs b/gen/dlp2_beta1/src/lib.rs index 363c8f4381..71e179df9a 100644 --- a/gen/dlp2_beta1/src/lib.rs +++ b/gen/dlp2_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dlp2_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DLP) ... +//! Handle the following *Resources* with ease from the central [hub](DLP) ... //! //! * content //! * [*deidentify*](api::ContentDeidentifyCall), [*inspect*](api::ContentInspectCall) and [*redact*](api::ContentRedactCall) @@ -61,8 +61,8 @@ //! let r = hub.inspect().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use dlp2_beta1::{DLP, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dns1/src/lib.rs b/gen/dns1/src/lib.rs index 11f9679c59..ed84045455 100644 --- a/gen/dns1/src/lib.rs +++ b/gen/dns1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dns1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dns) ... +//! Handle the following *Resources* with ease from the central [hub](Dns) ... //! //! * [changes](api::Change) //! * [*create*](api::ChangeCreateCall), [*get*](api::ChangeGetCall) and [*list*](api::ChangeListCall) @@ -74,8 +74,8 @@ //! let r = hub.managed_zones().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -103,12 +103,12 @@ //! use std::default::Default; //! use dns1::{Dns, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -147,10 +147,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -160,25 +160,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/dns2/src/lib.rs b/gen/dns2/src/lib.rs index 63e0d8c8d9..e6c9286855 100644 --- a/gen/dns2/src/lib.rs +++ b/gen/dns2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/dns2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Dns) ... +//! Handle the following *Resources* with ease from the central [hub](Dns) ... //! //! * [changes](api::Change) //! * [*create*](api::ChangeCreateCall), [*get*](api::ChangeGetCall) and [*list*](api::ChangeListCall) @@ -74,8 +74,8 @@ //! let r = hub.managed_zones().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -103,12 +103,12 @@ //! use std::default::Default; //! use dns2::{Dns, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -147,10 +147,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -160,25 +160,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/docs1/src/lib.rs b/gen/docs1/src/lib.rs index f349b91061..faa64d03e5 100644 --- a/gen/docs1/src/lib.rs +++ b/gen/docs1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/docs1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Docs) ... +//! Handle the following *Resources* with ease from the central [hub](Docs) ... //! //! * [documents](api::Document) //! * [*batch update*](api::DocumentBatchUpdateCall), [*create*](api::DocumentCreateCall) and [*get*](api::DocumentGetCall) @@ -52,8 +52,8 @@ //! let r = hub.documents().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use docs1::{Docs, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/documentai1/src/lib.rs b/gen/documentai1/src/lib.rs index 27e7a6eeb2..26e17975f0 100644 --- a/gen/documentai1/src/lib.rs +++ b/gen/documentai1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/documentai1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Document) ... +//! Handle the following *Resources* with ease from the central [hub](Document) ... //! //! * operations //! * [*delete*](api::OperationDeleteCall) @@ -65,8 +65,8 @@ //! let r = hub.projects().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -95,12 +95,12 @@ //! use std::default::Default; //! use documentai1::{Document, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/documentai1_beta2/src/lib.rs b/gen/documentai1_beta2/src/lib.rs index 6ca45c82f5..da7543bd19 100644 --- a/gen/documentai1_beta2/src/lib.rs +++ b/gen/documentai1_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/documentai1_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Document) ... +//! Handle the following *Resources* with ease from the central [hub](Document) ... //! //! * projects //! * [*documents batch process*](api::ProjectDocumentBatchProcesCall), [*documents process*](api::ProjectDocumentProcesCall), [*locations documents batch process*](api::ProjectLocationDocumentBatchProcesCall), [*locations documents process*](api::ProjectLocationDocumentProcesCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*operations get*](api::ProjectOperationGetCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use documentai1_beta2::{Document, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/domains1/src/lib.rs b/gen/domains1/src/lib.rs index b398185313..8caaa6bc5e 100644 --- a/gen/domains1/src/lib.rs +++ b/gen/domains1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/domains1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudDomains) ... +//! Handle the following *Resources* with ease from the central [hub](CloudDomains) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations registrations configure contact settings*](api::ProjectLocationRegistrationConfigureContactSettingCall), [*locations registrations configure dns settings*](api::ProjectLocationRegistrationConfigureDnsSettingCall), [*locations registrations configure management settings*](api::ProjectLocationRegistrationConfigureManagementSettingCall), [*locations registrations delete*](api::ProjectLocationRegistrationDeleteCall), [*locations registrations export*](api::ProjectLocationRegistrationExportCall), [*locations registrations get*](api::ProjectLocationRegistrationGetCall), [*locations registrations get iam policy*](api::ProjectLocationRegistrationGetIamPolicyCall), [*locations registrations import*](api::ProjectLocationRegistrationImportCall), [*locations registrations list*](api::ProjectLocationRegistrationListCall), [*locations registrations patch*](api::ProjectLocationRegistrationPatchCall), [*locations registrations register*](api::ProjectLocationRegistrationRegisterCall), [*locations registrations reset authorization code*](api::ProjectLocationRegistrationResetAuthorizationCodeCall), [*locations registrations retrieve authorization code*](api::ProjectLocationRegistrationRetrieveAuthorizationCodeCall), [*locations registrations retrieve importable domains*](api::ProjectLocationRegistrationRetrieveImportableDomainCall), [*locations registrations retrieve register parameters*](api::ProjectLocationRegistrationRetrieveRegisterParameterCall), [*locations registrations retrieve transfer parameters*](api::ProjectLocationRegistrationRetrieveTransferParameterCall), [*locations registrations search domains*](api::ProjectLocationRegistrationSearchDomainCall), [*locations registrations set iam policy*](api::ProjectLocationRegistrationSetIamPolicyCall), [*locations registrations test iam permissions*](api::ProjectLocationRegistrationTestIamPermissionCall) and [*locations registrations transfer*](api::ProjectLocationRegistrationTransferCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().locations_registrations_transfer(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use domains1::{CloudDomains, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/domains1_beta1/src/lib.rs b/gen/domains1_beta1/src/lib.rs index cfc330a48a..5591798873 100644 --- a/gen/domains1_beta1/src/lib.rs +++ b/gen/domains1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/domains1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudDomains) ... +//! Handle the following *Resources* with ease from the central [hub](CloudDomains) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations registrations configure contact settings*](api::ProjectLocationRegistrationConfigureContactSettingCall), [*locations registrations configure dns settings*](api::ProjectLocationRegistrationConfigureDnsSettingCall), [*locations registrations configure management settings*](api::ProjectLocationRegistrationConfigureManagementSettingCall), [*locations registrations delete*](api::ProjectLocationRegistrationDeleteCall), [*locations registrations export*](api::ProjectLocationRegistrationExportCall), [*locations registrations get*](api::ProjectLocationRegistrationGetCall), [*locations registrations get iam policy*](api::ProjectLocationRegistrationGetIamPolicyCall), [*locations registrations import*](api::ProjectLocationRegistrationImportCall), [*locations registrations list*](api::ProjectLocationRegistrationListCall), [*locations registrations patch*](api::ProjectLocationRegistrationPatchCall), [*locations registrations register*](api::ProjectLocationRegistrationRegisterCall), [*locations registrations reset authorization code*](api::ProjectLocationRegistrationResetAuthorizationCodeCall), [*locations registrations retrieve authorization code*](api::ProjectLocationRegistrationRetrieveAuthorizationCodeCall), [*locations registrations retrieve importable domains*](api::ProjectLocationRegistrationRetrieveImportableDomainCall), [*locations registrations retrieve register parameters*](api::ProjectLocationRegistrationRetrieveRegisterParameterCall), [*locations registrations retrieve transfer parameters*](api::ProjectLocationRegistrationRetrieveTransferParameterCall), [*locations registrations search domains*](api::ProjectLocationRegistrationSearchDomainCall), [*locations registrations set iam policy*](api::ProjectLocationRegistrationSetIamPolicyCall), [*locations registrations test iam permissions*](api::ProjectLocationRegistrationTestIamPermissionCall) and [*locations registrations transfer*](api::ProjectLocationRegistrationTransferCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().locations_registrations_transfer(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use domains1_beta1::{CloudDomains, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/domainsrdap1/src/api.rs b/gen/domainsrdap1/src/api.rs index 6571468a9b..3770fa272e 100644 --- a/gen/domainsrdap1/src/api.rs +++ b/gen/domainsrdap1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use domainsrdap1::{DomainsRDAP, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/domainsrdap1/src/lib.rs b/gen/domainsrdap1/src/lib.rs index 8bc2cac006..fd527091df 100644 --- a/gen/domainsrdap1/src/lib.rs +++ b/gen/domainsrdap1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/domainsrdap1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DomainsRDAP) ... +//! Handle the following *Resources* with ease from the central [hub](DomainsRDAP) ... //! //! * autnum //! * [*get*](api::AutnumGetCall) @@ -71,8 +71,8 @@ //! let r = hub.methods().get_nameservers(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -100,12 +100,12 @@ //! use std::default::Default; //! use domainsrdap1::{DomainsRDAP, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/doubleclickbidmanager1/src/lib.rs b/gen/doubleclickbidmanager1/src/lib.rs index d4caefca92..0e5ddfedb7 100644 --- a/gen/doubleclickbidmanager1/src/lib.rs +++ b/gen/doubleclickbidmanager1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/doubleclickbidmanager1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DoubleClickBidManager) ... +//! Handle the following *Resources* with ease from the central [hub](DoubleClickBidManager) ... //! //! * lineitems //! * [*downloadlineitems*](api::LineitemDownloadlineitemCall) and [*uploadlineitems*](api::LineitemUploadlineitemCall) @@ -57,8 +57,8 @@ //! let r = hub.queries().getquery(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use doubleclickbidmanager1::{DoubleClickBidManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/doubleclickbidmanager1d1/src/lib.rs b/gen/doubleclickbidmanager1d1/src/lib.rs index 42456b8002..1da75302d8 100644 --- a/gen/doubleclickbidmanager1d1/src/lib.rs +++ b/gen/doubleclickbidmanager1d1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/doubleclickbidmanager1d1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DoubleClickBidManager) ... +//! Handle the following *Resources* with ease from the central [hub](DoubleClickBidManager) ... //! //! * [queries](api::Query) //! * [*createquery*](api::QueryCreatequeryCall), [*deletequery*](api::QueryDeletequeryCall), [*getquery*](api::QueryGetqueryCall), [*listqueries*](api::QueryListqueryCall) and [*runquery*](api::QueryRunqueryCall) @@ -53,8 +53,8 @@ //! let r = hub.queries().getquery(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use doubleclickbidmanager1d1::{DoubleClickBidManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/doubleclicksearch2/src/lib.rs b/gen/doubleclicksearch2/src/lib.rs index 8a2e880982..8f9821a5f4 100644 --- a/gen/doubleclicksearch2/src/lib.rs +++ b/gen/doubleclicksearch2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/doubleclicksearch2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Doubleclicksearch) ... +//! Handle the following *Resources* with ease from the central [hub](Doubleclicksearch) ... //! //! * [conversion](api::Conversion) //! * [*get*](api::ConversionGetCall), [*get by customer id*](api::ConversionGetByCustomerIdCall), [*insert*](api::ConversionInsertCall), [*update*](api::ConversionUpdateCall) and [*update availability*](api::ConversionUpdateAvailabilityCall) @@ -63,8 +63,8 @@ //! let r = hub.reports().request(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use doubleclicksearch2::{Doubleclicksearch, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/drive2/src/lib.rs b/gen/drive2/src/lib.rs index d49b5324f7..b21f19c96b 100644 --- a/gen/drive2/src/lib.rs +++ b/gen/drive2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/drive2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DriveHub) ... +//! Handle the following *Resources* with ease from the central [hub](DriveHub) ... //! //! * [about](api::About) //! * [*get*](api::AboutGetCall) @@ -108,8 +108,8 @@ //! let r = hub.files().watch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -138,12 +138,12 @@ //! use std::default::Default; //! use drive2::{DriveHub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -202,10 +202,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -215,25 +215,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/drive3/src/lib.rs b/gen/drive3/src/lib.rs index 078f62937a..e358f5a29f 100644 --- a/gen/drive3/src/lib.rs +++ b/gen/drive3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/drive3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DriveHub) ... +//! Handle the following *Resources* with ease from the central [hub](DriveHub) ... //! //! * [about](api::About) //! * [*get*](api::AboutGetCall) @@ -99,8 +99,8 @@ //! let r = hub.files().watch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -128,12 +128,12 @@ //! use std::default::Default; //! use drive3::{DriveHub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -184,10 +184,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -197,25 +197,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/driveactivity2/src/lib.rs b/gen/driveactivity2/src/lib.rs index b8116b058a..428d2b184c 100644 --- a/gen/driveactivity2/src/lib.rs +++ b/gen/driveactivity2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/driveactivity2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DriveActivityHub) ... +//! Handle the following *Resources* with ease from the central [hub](DriveActivityHub) ... //! //! * activity //! * [*query*](api::ActivityQueryCall) @@ -50,8 +50,8 @@ //! let r = hub.activity().query(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use driveactivity2::{DriveActivityHub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/essentialcontacts1/src/lib.rs b/gen/essentialcontacts1/src/lib.rs index 72bb7b828e..f138f73ce2 100644 --- a/gen/essentialcontacts1/src/lib.rs +++ b/gen/essentialcontacts1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/essentialcontacts1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Essentialcontacts) ... +//! Handle the following *Resources* with ease from the central [hub](Essentialcontacts) ... //! //! * folders //! * [*contacts compute*](api::FolderContactComputeCall), [*contacts create*](api::FolderContactCreateCall), [*contacts delete*](api::FolderContactDeleteCall), [*contacts get*](api::FolderContactGetCall), [*contacts list*](api::FolderContactListCall), [*contacts patch*](api::FolderContactPatchCall) and [*contacts send test message*](api::FolderContactSendTestMessageCall) @@ -62,8 +62,8 @@ //! let r = hub.projects().contacts_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use essentialcontacts1::{Essentialcontacts, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -139,10 +139,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -152,25 +152,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/eventarc1/src/lib.rs b/gen/eventarc1/src/lib.rs index ce3e22c457..4e6987733a 100644 --- a/gen/eventarc1/src/lib.rs +++ b/gen/eventarc1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/eventarc1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Eventarc) ... +//! Handle the following *Resources* with ease from the central [hub](Eventarc) ... //! //! * projects //! * [*locations channel connections create*](api::ProjectLocationChannelConnectionCreateCall), [*locations channel connections delete*](api::ProjectLocationChannelConnectionDeleteCall), [*locations channel connections get*](api::ProjectLocationChannelConnectionGetCall), [*locations channel connections get iam policy*](api::ProjectLocationChannelConnectionGetIamPolicyCall), [*locations channel connections list*](api::ProjectLocationChannelConnectionListCall), [*locations channel connections set iam policy*](api::ProjectLocationChannelConnectionSetIamPolicyCall), [*locations channel connections test iam permissions*](api::ProjectLocationChannelConnectionTestIamPermissionCall), [*locations channels create*](api::ProjectLocationChannelCreateCall), [*locations channels delete*](api::ProjectLocationChannelDeleteCall), [*locations channels get*](api::ProjectLocationChannelGetCall), [*locations channels get iam policy*](api::ProjectLocationChannelGetIamPolicyCall), [*locations channels list*](api::ProjectLocationChannelListCall), [*locations channels patch*](api::ProjectLocationChannelPatchCall), [*locations channels set iam policy*](api::ProjectLocationChannelSetIamPolicyCall), [*locations channels test iam permissions*](api::ProjectLocationChannelTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations get google channel config*](api::ProjectLocationGetGoogleChannelConfigCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations providers get*](api::ProjectLocationProviderGetCall), [*locations providers list*](api::ProjectLocationProviderListCall), [*locations triggers create*](api::ProjectLocationTriggerCreateCall), [*locations triggers delete*](api::ProjectLocationTriggerDeleteCall), [*locations triggers get*](api::ProjectLocationTriggerGetCall), [*locations triggers get iam policy*](api::ProjectLocationTriggerGetIamPolicyCall), [*locations triggers list*](api::ProjectLocationTriggerListCall), [*locations triggers patch*](api::ProjectLocationTriggerPatchCall), [*locations triggers set iam policy*](api::ProjectLocationTriggerSetIamPolicyCall), [*locations triggers test iam permissions*](api::ProjectLocationTriggerTestIamPermissionCall) and [*locations update google channel config*](api::ProjectLocationUpdateGoogleChannelConfigCall) @@ -58,8 +58,8 @@ //! let r = hub.projects().locations_triggers_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use eventarc1::{Eventarc, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -137,10 +137,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -150,25 +150,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/factchecktools1_alpha1/src/lib.rs b/gen/factchecktools1_alpha1/src/lib.rs index 0c6858829c..581dddae6e 100644 --- a/gen/factchecktools1_alpha1/src/lib.rs +++ b/gen/factchecktools1_alpha1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/factchecktools1_alpha1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FactCheckTools) ... +//! Handle the following *Resources* with ease from the central [hub](FactCheckTools) ... //! //! * claims //! * [*search*](api::ClaimSearchCall) @@ -54,8 +54,8 @@ //! let r = hub.pages().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use factchecktools1_alpha1::{FactCheckTools, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/fcm1/src/lib.rs b/gen/fcm1/src/lib.rs index b10e481373..af6b1d90d3 100644 --- a/gen/fcm1/src/lib.rs +++ b/gen/fcm1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/fcm1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FirebaseCloudMessaging) ... +//! Handle the following *Resources* with ease from the central [hub](FirebaseCloudMessaging) ... //! //! * projects //! * [*messages send*](api::ProjectMessageSendCall) @@ -50,8 +50,8 @@ //! let r = hub.projects().messages_send(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use fcm1::{FirebaseCloudMessaging, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/fcmdata1_beta1/src/lib.rs b/gen/fcmdata1_beta1/src/lib.rs index a823034558..c74d1943a1 100644 --- a/gen/fcmdata1_beta1/src/lib.rs +++ b/gen/fcmdata1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/fcmdata1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Fcmdata) ... +//! Handle the following *Resources* with ease from the central [hub](Fcmdata) ... //! //! * projects //! * [*android apps delivery data list*](api::ProjectAndroidAppDeliveryDataListCall) @@ -50,8 +50,8 @@ //! let r = hub.projects().android_apps_delivery_data_list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use fcmdata1_beta1::{Fcmdata, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -122,10 +122,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -135,25 +135,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/file1/src/lib.rs b/gen/file1/src/lib.rs index 5b887316c1..c33cbe02e0 100644 --- a/gen/file1/src/lib.rs +++ b/gen/file1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/file1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudFilestore) ... +//! Handle the following *Resources* with ease from the central [hub](CloudFilestore) ... //! //! * projects //! * [*locations backups create*](api::ProjectLocationBackupCreateCall), [*locations backups delete*](api::ProjectLocationBackupDeleteCall), [*locations backups get*](api::ProjectLocationBackupGetCall), [*locations backups list*](api::ProjectLocationBackupListCall), [*locations backups patch*](api::ProjectLocationBackupPatchCall), [*locations get*](api::ProjectLocationGetCall), [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances patch*](api::ProjectLocationInstancePatchCall), [*locations instances restore*](api::ProjectLocationInstanceRestoreCall), [*locations instances revert*](api::ProjectLocationInstanceRevertCall), [*locations instances snapshots create*](api::ProjectLocationInstanceSnapshotCreateCall), [*locations instances snapshots delete*](api::ProjectLocationInstanceSnapshotDeleteCall), [*locations instances snapshots get*](api::ProjectLocationInstanceSnapshotGetCall), [*locations instances snapshots list*](api::ProjectLocationInstanceSnapshotListCall), [*locations instances snapshots patch*](api::ProjectLocationInstanceSnapshotPatchCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -61,8 +61,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use file1::{CloudFilestore, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -138,10 +138,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -151,25 +151,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/file1_beta1/src/lib.rs b/gen/file1_beta1/src/lib.rs index ec1746c488..dd58712a06 100644 --- a/gen/file1_beta1/src/lib.rs +++ b/gen/file1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/file1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudFilestore) ... +//! Handle the following *Resources* with ease from the central [hub](CloudFilestore) ... //! //! * projects //! * [*locations backups create*](api::ProjectLocationBackupCreateCall), [*locations backups delete*](api::ProjectLocationBackupDeleteCall), [*locations backups get*](api::ProjectLocationBackupGetCall), [*locations backups list*](api::ProjectLocationBackupListCall), [*locations backups patch*](api::ProjectLocationBackupPatchCall), [*locations get*](api::ProjectLocationGetCall), [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances patch*](api::ProjectLocationInstancePatchCall), [*locations instances restore*](api::ProjectLocationInstanceRestoreCall), [*locations instances revert*](api::ProjectLocationInstanceRevertCall), [*locations instances shares create*](api::ProjectLocationInstanceShareCreateCall), [*locations instances shares delete*](api::ProjectLocationInstanceShareDeleteCall), [*locations instances shares get*](api::ProjectLocationInstanceShareGetCall), [*locations instances shares list*](api::ProjectLocationInstanceShareListCall), [*locations instances shares patch*](api::ProjectLocationInstanceSharePatchCall), [*locations instances snapshots create*](api::ProjectLocationInstanceSnapshotCreateCall), [*locations instances snapshots delete*](api::ProjectLocationInstanceSnapshotDeleteCall), [*locations instances snapshots get*](api::ProjectLocationInstanceSnapshotGetCall), [*locations instances snapshots list*](api::ProjectLocationInstanceSnapshotListCall), [*locations instances snapshots patch*](api::ProjectLocationInstanceSnapshotPatchCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -64,8 +64,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -94,12 +94,12 @@ //! use std::default::Default; //! use file1_beta1::{CloudFilestore, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebase1_beta1/src/lib.rs b/gen/firebase1_beta1/src/lib.rs index 02eed1603f..2f2f71b228 100644 --- a/gen/firebase1_beta1/src/lib.rs +++ b/gen/firebase1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebase1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FirebaseManagement) ... +//! Handle the following *Resources* with ease from the central [hub](FirebaseManagement) ... //! //! * available projects //! * [*list*](api::AvailableProjectListCall) @@ -66,8 +66,8 @@ //! let r = hub.projects().add_google_analytics(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use firebase1_beta1::{FirebaseManagement, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -142,10 +142,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -155,25 +155,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebaseappcheck1_beta/src/lib.rs b/gen/firebaseappcheck1_beta/src/lib.rs index 8db19c9ccd..1e15cdddfc 100644 --- a/gen/firebaseappcheck1_beta/src/lib.rs +++ b/gen/firebaseappcheck1_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebaseappcheck1_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Firebaseappcheck) ... +//! Handle the following *Resources* with ease from the central [hub](Firebaseappcheck) ... //! //! * jwks //! * [*get*](api::JwkGetCall) @@ -64,8 +64,8 @@ //! let r = hub.projects().apps_exchange_safety_net_token(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -94,12 +94,12 @@ //! use std::default::Default; //! use firebaseappcheck1_beta::{Firebaseappcheck, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -140,10 +140,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -153,25 +153,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebasedatabase1_beta/src/lib.rs b/gen/firebasedatabase1_beta/src/lib.rs index 25711db818..3c27077d49 100644 --- a/gen/firebasedatabase1_beta/src/lib.rs +++ b/gen/firebasedatabase1_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebasedatabase1_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FirebaseRealtimeDatabase) ... +//! Handle the following *Resources* with ease from the central [hub](FirebaseRealtimeDatabase) ... //! //! * projects //! * [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances disable*](api::ProjectLocationInstanceDisableCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances reenable*](api::ProjectLocationInstanceReenableCall) and [*locations instances undelete*](api::ProjectLocationInstanceUndeleteCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_instances_undelete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use firebasedatabase1_beta::{FirebaseRealtimeDatabase, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebasedynamiclinks1/src/lib.rs b/gen/firebasedynamiclinks1/src/lib.rs index ec1be35030..b9fc170b7e 100644 --- a/gen/firebasedynamiclinks1/src/lib.rs +++ b/gen/firebasedynamiclinks1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebasedynamiclinks1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FirebaseDynamicLinks) ... +//! Handle the following *Resources* with ease from the central [hub](FirebaseDynamicLinks) ... //! //! * [managed short links](api::ManagedShortLink) //! * [*create*](api::ManagedShortLinkCreateCall) @@ -57,8 +57,8 @@ //! let r = hub.methods().install_attribution(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use firebasedynamiclinks1::{FirebaseDynamicLinks, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebasehosting1/src/api.rs b/gen/firebasehosting1/src/api.rs index 1c01f95d0a..1c21fec79d 100644 --- a/gen/firebasehosting1/src/api.rs +++ b/gen/firebasehosting1/src/api.rs @@ -69,12 +69,12 @@ impl Default for Scope { /// use std::default::Default; /// use firebasehosting1::{FirebaseHosting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/firebasehosting1/src/lib.rs b/gen/firebasehosting1/src/lib.rs index ab0c445eeb..ae7bdd786c 100644 --- a/gen/firebasehosting1/src/lib.rs +++ b/gen/firebasehosting1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebasehosting1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FirebaseHosting) ... +//! Handle the following *Resources* with ease from the central [hub](FirebaseHosting) ... //! //! * [operations](api::Operation) //! * [*cancel*](api::OperationCancelCall), [*delete*](api::OperationDeleteCall) and [*list*](api::OperationListCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().sites_custom_domains_operations_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use firebasehosting1::{FirebaseHosting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebasehosting1_beta1/src/lib.rs b/gen/firebasehosting1_beta1/src/lib.rs index adecce0ee6..a0893d19be 100644 --- a/gen/firebasehosting1_beta1/src/lib.rs +++ b/gen/firebasehosting1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebasehosting1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FirebaseHosting) ... +//! Handle the following *Resources* with ease from the central [hub](FirebaseHosting) ... //! //! * projects //! * [*operations get*](api::ProjectOperationGetCall), [*sites channels create*](api::ProjectSiteChannelCreateCall), [*sites channels delete*](api::ProjectSiteChannelDeleteCall), [*sites channels get*](api::ProjectSiteChannelGetCall), [*sites channels list*](api::ProjectSiteChannelListCall), [*sites channels patch*](api::ProjectSiteChannelPatchCall), [*sites channels releases create*](api::ProjectSiteChannelReleaseCreateCall), [*sites channels releases get*](api::ProjectSiteChannelReleaseGetCall), [*sites channels releases list*](api::ProjectSiteChannelReleaseListCall), [*sites create*](api::ProjectSiteCreateCall), [*sites custom domains create*](api::ProjectSiteCustomDomainCreateCall), [*sites custom domains delete*](api::ProjectSiteCustomDomainDeleteCall), [*sites custom domains get*](api::ProjectSiteCustomDomainGetCall), [*sites custom domains list*](api::ProjectSiteCustomDomainListCall), [*sites custom domains operations get*](api::ProjectSiteCustomDomainOperationGetCall), [*sites custom domains operations list*](api::ProjectSiteCustomDomainOperationListCall), [*sites custom domains patch*](api::ProjectSiteCustomDomainPatchCall), [*sites custom domains undelete*](api::ProjectSiteCustomDomainUndeleteCall), [*sites delete*](api::ProjectSiteDeleteCall), [*sites domains create*](api::ProjectSiteDomainCreateCall), [*sites domains delete*](api::ProjectSiteDomainDeleteCall), [*sites domains get*](api::ProjectSiteDomainGetCall), [*sites domains list*](api::ProjectSiteDomainListCall), [*sites domains update*](api::ProjectSiteDomainUpdateCall), [*sites get*](api::ProjectSiteGetCall), [*sites get config*](api::ProjectSiteGetConfigCall), [*sites list*](api::ProjectSiteListCall), [*sites patch*](api::ProjectSitePatchCall), [*sites releases create*](api::ProjectSiteReleaseCreateCall), [*sites releases get*](api::ProjectSiteReleaseGetCall), [*sites releases list*](api::ProjectSiteReleaseListCall), [*sites update config*](api::ProjectSiteUpdateConfigCall), [*sites versions clone*](api::ProjectSiteVersionCloneCall), [*sites versions create*](api::ProjectSiteVersionCreateCall), [*sites versions delete*](api::ProjectSiteVersionDeleteCall), [*sites versions files list*](api::ProjectSiteVersionFileListCall), [*sites versions get*](api::ProjectSiteVersionGetCall), [*sites versions list*](api::ProjectSiteVersionListCall), [*sites versions patch*](api::ProjectSiteVersionPatchCall) and [*sites versions populate files*](api::ProjectSiteVersionPopulateFileCall) @@ -80,8 +80,8 @@ //! let r = hub.sites().update_config(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -110,12 +110,12 @@ //! use std::default::Default; //! use firebasehosting1_beta1::{FirebaseHosting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -158,10 +158,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -171,25 +171,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebaseml1/src/lib.rs b/gen/firebaseml1/src/lib.rs index 6ace012016..3295b91b3d 100644 --- a/gen/firebaseml1/src/lib.rs +++ b/gen/firebaseml1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebaseml1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FirebaseML) ... +//! Handle the following *Resources* with ease from the central [hub](FirebaseML) ... //! //! * [operations](api::Operation) //! * [*cancel*](api::OperationCancelCall), [*delete*](api::OperationDeleteCall) and [*list*](api::OperationListCall) @@ -52,8 +52,8 @@ //! let r = hub.operations().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use firebaseml1::{FirebaseML, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -125,10 +125,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -138,25 +138,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebaseremoteconfig1/src/api.rs b/gen/firebaseremoteconfig1/src/api.rs index e474a164aa..5ed43099ab 100644 --- a/gen/firebaseremoteconfig1/src/api.rs +++ b/gen/firebaseremoteconfig1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use firebaseremoteconfig1::{FirebaseRemoteConfig, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/firebaseremoteconfig1/src/lib.rs b/gen/firebaseremoteconfig1/src/lib.rs index 412a7c0dc8..465d4b9096 100644 --- a/gen/firebaseremoteconfig1/src/lib.rs +++ b/gen/firebaseremoteconfig1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebaseremoteconfig1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](FirebaseRemoteConfig) ... +//! Handle the following *Resources* with ease from the central [hub](FirebaseRemoteConfig) ... //! //! * projects //! * [*get remote config*](api::ProjectGetRemoteConfigCall) and [*update remote config*](api::ProjectUpdateRemoteConfigCall) @@ -51,8 +51,8 @@ //! let r = hub.projects().update_remote_config(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use firebaseremoteconfig1::{FirebaseRemoteConfig, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firebasestorage1_beta/src/lib.rs b/gen/firebasestorage1_beta/src/lib.rs index deb34da466..5d3c7f8087 100644 --- a/gen/firebasestorage1_beta/src/lib.rs +++ b/gen/firebasestorage1_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firebasestorage1_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Firebasestorage) ... +//! Handle the following *Resources* with ease from the central [hub](Firebasestorage) ... //! //! * projects //! * [*buckets add firebase*](api::ProjectBucketAddFirebaseCall), [*buckets get*](api::ProjectBucketGetCall), [*buckets list*](api::ProjectBucketListCall) and [*buckets remove firebase*](api::ProjectBucketRemoveFirebaseCall) @@ -51,8 +51,8 @@ //! let r = hub.projects().buckets_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use firebasestorage1_beta::{Firebasestorage, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firestore1/src/lib.rs b/gen/firestore1/src/lib.rs index 3c9a1e2ae6..69743adb22 100644 --- a/gen/firestore1/src/lib.rs +++ b/gen/firestore1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firestore1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Firestore) ... +//! Handle the following *Resources* with ease from the central [hub](Firestore) ... //! //! * projects //! * [*databases backup schedules create*](api::ProjectDatabaseBackupScheduleCreateCall), [*databases backup schedules delete*](api::ProjectDatabaseBackupScheduleDeleteCall), [*databases backup schedules get*](api::ProjectDatabaseBackupScheduleGetCall), [*databases backup schedules list*](api::ProjectDatabaseBackupScheduleListCall), [*databases backup schedules patch*](api::ProjectDatabaseBackupSchedulePatchCall), [*databases collection groups fields get*](api::ProjectDatabaseCollectionGroupFieldGetCall), [*databases collection groups fields list*](api::ProjectDatabaseCollectionGroupFieldListCall), [*databases collection groups fields patch*](api::ProjectDatabaseCollectionGroupFieldPatchCall), [*databases collection groups indexes create*](api::ProjectDatabaseCollectionGroupIndexCreateCall), [*databases collection groups indexes delete*](api::ProjectDatabaseCollectionGroupIndexDeleteCall), [*databases collection groups indexes get*](api::ProjectDatabaseCollectionGroupIndexGetCall), [*databases collection groups indexes list*](api::ProjectDatabaseCollectionGroupIndexListCall), [*databases create*](api::ProjectDatabaseCreateCall), [*databases delete*](api::ProjectDatabaseDeleteCall), [*databases documents batch get*](api::ProjectDatabaseDocumentBatchGetCall), [*databases documents batch write*](api::ProjectDatabaseDocumentBatchWriteCall), [*databases documents begin transaction*](api::ProjectDatabaseDocumentBeginTransactionCall), [*databases documents commit*](api::ProjectDatabaseDocumentCommitCall), [*databases documents create document*](api::ProjectDatabaseDocumentCreateDocumentCall), [*databases documents delete*](api::ProjectDatabaseDocumentDeleteCall), [*databases documents get*](api::ProjectDatabaseDocumentGetCall), [*databases documents list*](api::ProjectDatabaseDocumentListCall), [*databases documents list collection ids*](api::ProjectDatabaseDocumentListCollectionIdCall), [*databases documents list documents*](api::ProjectDatabaseDocumentListDocumentCall), [*databases documents listen*](api::ProjectDatabaseDocumentListenCall), [*databases documents partition query*](api::ProjectDatabaseDocumentPartitionQueryCall), [*databases documents patch*](api::ProjectDatabaseDocumentPatchCall), [*databases documents rollback*](api::ProjectDatabaseDocumentRollbackCall), [*databases documents run aggregation query*](api::ProjectDatabaseDocumentRunAggregationQueryCall), [*databases documents run query*](api::ProjectDatabaseDocumentRunQueryCall), [*databases documents write*](api::ProjectDatabaseDocumentWriteCall), [*databases export documents*](api::ProjectDatabaseExportDocumentCall), [*databases get*](api::ProjectDatabaseGetCall), [*databases import documents*](api::ProjectDatabaseImportDocumentCall), [*databases list*](api::ProjectDatabaseListCall), [*databases operations cancel*](api::ProjectDatabaseOperationCancelCall), [*databases operations delete*](api::ProjectDatabaseOperationDeleteCall), [*databases operations get*](api::ProjectDatabaseOperationGetCall), [*databases operations list*](api::ProjectDatabaseOperationListCall), [*databases patch*](api::ProjectDatabasePatchCall), [*databases restore*](api::ProjectDatabaseRestoreCall), [*locations backups delete*](api::ProjectLocationBackupDeleteCall), [*locations backups get*](api::ProjectLocationBackupGetCall), [*locations backups list*](api::ProjectLocationBackupListCall), [*locations get*](api::ProjectLocationGetCall) and [*locations list*](api::ProjectLocationListCall) @@ -58,8 +58,8 @@ //! let r = hub.projects().databases_restore(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use firestore1::{Firestore, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/firestore1_beta1/src/lib.rs b/gen/firestore1_beta1/src/lib.rs index f0f8e824b4..18c7b15730 100644 --- a/gen/firestore1_beta1/src/lib.rs +++ b/gen/firestore1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/firestore1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Firestore) ... +//! Handle the following *Resources* with ease from the central [hub](Firestore) ... //! //! * projects //! * [*databases documents batch get*](api::ProjectDatabaseDocumentBatchGetCall), [*databases documents batch write*](api::ProjectDatabaseDocumentBatchWriteCall), [*databases documents begin transaction*](api::ProjectDatabaseDocumentBeginTransactionCall), [*databases documents commit*](api::ProjectDatabaseDocumentCommitCall), [*databases documents create document*](api::ProjectDatabaseDocumentCreateDocumentCall), [*databases documents delete*](api::ProjectDatabaseDocumentDeleteCall), [*databases documents get*](api::ProjectDatabaseDocumentGetCall), [*databases documents list*](api::ProjectDatabaseDocumentListCall), [*databases documents list collection ids*](api::ProjectDatabaseDocumentListCollectionIdCall), [*databases documents list documents*](api::ProjectDatabaseDocumentListDocumentCall), [*databases documents listen*](api::ProjectDatabaseDocumentListenCall), [*databases documents partition query*](api::ProjectDatabaseDocumentPartitionQueryCall), [*databases documents patch*](api::ProjectDatabaseDocumentPatchCall), [*databases documents rollback*](api::ProjectDatabaseDocumentRollbackCall), [*databases documents run aggregation query*](api::ProjectDatabaseDocumentRunAggregationQueryCall), [*databases documents run query*](api::ProjectDatabaseDocumentRunQueryCall), [*databases documents write*](api::ProjectDatabaseDocumentWriteCall), [*databases export documents*](api::ProjectDatabaseExportDocumentCall), [*databases import documents*](api::ProjectDatabaseImportDocumentCall), [*databases indexes create*](api::ProjectDatabaseIndexCreateCall), [*databases indexes delete*](api::ProjectDatabaseIndexDeleteCall), [*databases indexes get*](api::ProjectDatabaseIndexGetCall) and [*databases indexes list*](api::ProjectDatabaseIndexListCall) @@ -52,8 +52,8 @@ //! let r = hub.projects().databases_import_documents(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use firestore1_beta1::{Firestore, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/fitness1/src/lib.rs b/gen/fitness1/src/lib.rs index 1a96f2a664..c033b08e7a 100644 --- a/gen/fitness1/src/lib.rs +++ b/gen/fitness1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/fitness1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Fitness) ... +//! Handle the following *Resources* with ease from the central [hub](Fitness) ... //! //! * users //! * [*data sources create*](api::UserDataSourceCreateCall), [*data sources data point changes list*](api::UserDataSourceDataPointChangeListCall), [*data sources datasets delete*](api::UserDataSourceDatasetDeleteCall), [*data sources datasets get*](api::UserDataSourceDatasetGetCall), [*data sources datasets patch*](api::UserDataSourceDatasetPatchCall), [*data sources delete*](api::UserDataSourceDeleteCall), [*data sources get*](api::UserDataSourceGetCall), [*data sources list*](api::UserDataSourceListCall), [*data sources update*](api::UserDataSourceUpdateCall), [*dataset aggregate*](api::UserDatasetAggregateCall), [*sessions delete*](api::UserSessionDeleteCall), [*sessions list*](api::UserSessionListCall) and [*sessions update*](api::UserSessionUpdateCall) @@ -53,8 +53,8 @@ //! let r = hub.users().data_sources_update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use fitness1::{Fitness, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/fusiontables2/src/lib.rs b/gen/fusiontables2/src/lib.rs index 400ff19039..f64be339ed 100644 --- a/gen/fusiontables2/src/lib.rs +++ b/gen/fusiontables2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/fusiontables2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Fusiontables) ... +//! Handle the following *Resources* with ease from the central [hub](Fusiontables) ... //! //! * [column](api::Column) //! * [*delete*](api::ColumnDeleteCall), [*get*](api::ColumnGetCall), [*insert*](api::ColumnInsertCall), [*list*](api::ColumnListCall), [*patch*](api::ColumnPatchCall) and [*update*](api::ColumnUpdateCall) @@ -76,8 +76,8 @@ //! let r = hub.table().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -106,12 +106,12 @@ //! use std::default::Default; //! use fusiontables2::{Fusiontables, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -149,10 +149,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -162,25 +162,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/games1/src/lib.rs b/gen/games1/src/lib.rs index 3ca9a4490f..a2ff737dd7 100644 --- a/gen/games1/src/lib.rs +++ b/gen/games1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/games1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Games) ... +//! Handle the following *Resources* with ease from the central [hub](Games) ... //! //! * [achievement definitions](api::AchievementDefinition) //! * [*list*](api::AchievementDefinitionListCall) @@ -75,8 +75,8 @@ //! let r = hub.applications().verify(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -104,12 +104,12 @@ //! use std::default::Default; //! use games1::{Games, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -147,10 +147,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -160,25 +160,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/gamesconfiguration1_configuration/src/lib.rs b/gen/gamesconfiguration1_configuration/src/lib.rs index 833e476972..bfd7faddeb 100644 --- a/gen/gamesconfiguration1_configuration/src/lib.rs +++ b/gen/gamesconfiguration1_configuration/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/gamesconfiguration1_configuration). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](GamesConfiguration) ... +//! Handle the following *Resources* with ease from the central [hub](GamesConfiguration) ... //! //! * [achievement configurations](api::AchievementConfiguration) //! * [*delete*](api::AchievementConfigurationDeleteCall), [*get*](api::AchievementConfigurationGetCall), [*insert*](api::AchievementConfigurationInsertCall), [*list*](api::AchievementConfigurationListCall) and [*update*](api::AchievementConfigurationUpdateCall) @@ -56,8 +56,8 @@ //! let r = hub.achievement_configurations().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use gamesconfiguration1_configuration::{GamesConfiguration, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/gameservices1/src/lib.rs b/gen/gameservices1/src/lib.rs index f9bfc038b9..e10b55c97d 100644 --- a/gen/gameservices1/src/lib.rs +++ b/gen/gameservices1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/gameservices1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](GameServices) ... +//! Handle the following *Resources* with ease from the central [hub](GameServices) ... //! //! * projects //! * [*locations game server deployments get iam policy*](api::ProjectLocationGameServerDeploymentGetIamPolicyCall), [*locations game server deployments set iam policy*](api::ProjectLocationGameServerDeploymentSetIamPolicyCall), [*locations game server deployments test iam permissions*](api::ProjectLocationGameServerDeploymentTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -51,8 +51,8 @@ //! let r = hub.projects().locations_game_server_deployments_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use gameservices1::{GameServices, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -122,10 +122,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -135,25 +135,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/gamesmanagement1_management/src/lib.rs b/gen/gamesmanagement1_management/src/lib.rs index 399737c237..b73e975f08 100644 --- a/gen/gamesmanagement1_management/src/lib.rs +++ b/gen/gamesmanagement1_management/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/gamesmanagement1_management). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](GamesManagement) ... +//! Handle the following *Resources* with ease from the central [hub](GamesManagement) ... //! //! * achievements //! * [*reset*](api::AchievementResetCall), [*reset all*](api::AchievementResetAllCall), [*reset all for all players*](api::AchievementResetAllForAllPlayerCall), [*reset for all players*](api::AchievementResetForAllPlayerCall) and [*reset multiple for all players*](api::AchievementResetMultipleForAllPlayerCall) @@ -59,8 +59,8 @@ //! let r = hub.players().unhide(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use gamesmanagement1_management::{GamesManagement, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/gan1_beta1/src/api.rs b/gen/gan1_beta1/src/api.rs index f28041f276..274ed980ab 100644 --- a/gen/gan1_beta1/src/api.rs +++ b/gen/gan1_beta1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use gan1_beta1::{Gan, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/gan1_beta1/src/lib.rs b/gen/gan1_beta1/src/lib.rs index 5475cad39f..8d994b3044 100644 --- a/gen/gan1_beta1/src/lib.rs +++ b/gen/gan1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/gan1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Gan) ... +//! Handle the following *Resources* with ease from the central [hub](Gan) ... //! //! * [advertisers](api::Advertiser) //! * [*get*](api::AdvertiserGetCall) and [*list*](api::AdvertiserListCall) @@ -62,8 +62,8 @@ //! let r = hub.links().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use gan1_beta1::{Gan, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -145,10 +145,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -158,25 +158,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/genomics1/src/lib.rs b/gen/genomics1/src/lib.rs index 0dfb8d1115..6092378271 100644 --- a/gen/genomics1/src/lib.rs +++ b/gen/genomics1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/genomics1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Genomics) ... +//! Handle the following *Resources* with ease from the central [hub](Genomics) ... //! //! * [operations](api::Operation) //! * [*cancel*](api::OperationCancelCall), [*get*](api::OperationGetCall) and [*list*](api::OperationListCall) @@ -52,8 +52,8 @@ //! let r = hub.operations().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use genomics1::{Genomics, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -125,10 +125,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -138,25 +138,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/gkehub1/src/lib.rs b/gen/gkehub1/src/lib.rs index 10962ef920..d28ab02fd5 100644 --- a/gen/gkehub1/src/lib.rs +++ b/gen/gkehub1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/gkehub1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](GKEHub) ... +//! Handle the following *Resources* with ease from the central [hub](GKEHub) ... //! //! * organizations //! * [*locations fleets list*](api::OrganizationLocationFleetListCall) @@ -73,8 +73,8 @@ //! let r = hub.projects().locations_scopes_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -103,12 +103,12 @@ //! use std::default::Default; //! use gkehub1::{GKEHub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -151,10 +151,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -164,25 +164,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/gmail1/src/lib.rs b/gen/gmail1/src/lib.rs index faedd20819..4e87410ccf 100644 --- a/gen/gmail1/src/lib.rs +++ b/gen/gmail1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/gmail1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Gmail) ... +//! Handle the following *Resources* with ease from the central [hub](Gmail) ... //! //! * users //! * [*drafts create*](api::UserDraftCreateCall), [*drafts delete*](api::UserDraftDeleteCall), [*drafts get*](api::UserDraftGetCall), [*drafts list*](api::UserDraftListCall), [*drafts send*](api::UserDraftSendCall), [*drafts update*](api::UserDraftUpdateCall), [*get profile*](api::UserGetProfileCall), [*history list*](api::UserHistoryListCall), [*labels create*](api::UserLabelCreateCall), [*labels delete*](api::UserLabelDeleteCall), [*labels get*](api::UserLabelGetCall), [*labels list*](api::UserLabelListCall), [*labels patch*](api::UserLabelPatchCall), [*labels update*](api::UserLabelUpdateCall), [*messages attachments get*](api::UserMessageAttachmentGetCall), [*messages batch delete*](api::UserMessageBatchDeleteCall), [*messages batch modify*](api::UserMessageBatchModifyCall), [*messages delete*](api::UserMessageDeleteCall), [*messages get*](api::UserMessageGetCall), [*messages import*](api::UserMessageImportCall), [*messages insert*](api::UserMessageInsertCall), [*messages list*](api::UserMessageListCall), [*messages modify*](api::UserMessageModifyCall), [*messages send*](api::UserMessageSendCall), [*messages trash*](api::UserMessageTrashCall), [*messages untrash*](api::UserMessageUntrashCall), [*settings cse identities create*](api::UserSettingCseIdentityCreateCall), [*settings cse identities delete*](api::UserSettingCseIdentityDeleteCall), [*settings cse identities get*](api::UserSettingCseIdentityGetCall), [*settings cse identities list*](api::UserSettingCseIdentityListCall), [*settings cse identities patch*](api::UserSettingCseIdentityPatchCall), [*settings cse keypairs create*](api::UserSettingCseKeypairCreateCall), [*settings cse keypairs disable*](api::UserSettingCseKeypairDisableCall), [*settings cse keypairs enable*](api::UserSettingCseKeypairEnableCall), [*settings cse keypairs get*](api::UserSettingCseKeypairGetCall), [*settings cse keypairs list*](api::UserSettingCseKeypairListCall), [*settings cse keypairs obliterate*](api::UserSettingCseKeypairObliterateCall), [*settings delegates create*](api::UserSettingDelegateCreateCall), [*settings delegates delete*](api::UserSettingDelegateDeleteCall), [*settings delegates get*](api::UserSettingDelegateGetCall), [*settings delegates list*](api::UserSettingDelegateListCall), [*settings filters create*](api::UserSettingFilterCreateCall), [*settings filters delete*](api::UserSettingFilterDeleteCall), [*settings filters get*](api::UserSettingFilterGetCall), [*settings filters list*](api::UserSettingFilterListCall), [*settings forwarding addresses create*](api::UserSettingForwardingAddressCreateCall), [*settings forwarding addresses delete*](api::UserSettingForwardingAddressDeleteCall), [*settings forwarding addresses get*](api::UserSettingForwardingAddressGetCall), [*settings forwarding addresses list*](api::UserSettingForwardingAddressListCall), [*settings get auto forwarding*](api::UserSettingGetAutoForwardingCall), [*settings get imap*](api::UserSettingGetImapCall), [*settings get language*](api::UserSettingGetLanguageCall), [*settings get pop*](api::UserSettingGetPopCall), [*settings get vacation*](api::UserSettingGetVacationCall), [*settings send as create*](api::UserSettingSendACreateCall), [*settings send as delete*](api::UserSettingSendADeleteCall), [*settings send as get*](api::UserSettingSendAGetCall), [*settings send as list*](api::UserSettingSendAListCall), [*settings send as patch*](api::UserSettingSendAPatchCall), [*settings send as smime info delete*](api::UserSettingSendASmimeInfoDeleteCall), [*settings send as smime info get*](api::UserSettingSendASmimeInfoGetCall), [*settings send as smime info insert*](api::UserSettingSendASmimeInfoInsertCall), [*settings send as smime info list*](api::UserSettingSendASmimeInfoListCall), [*settings send as smime info set default*](api::UserSettingSendASmimeInfoSetDefaultCall), [*settings send as update*](api::UserSettingSendAUpdateCall), [*settings send as verify*](api::UserSettingSendAVerifyCall), [*settings update auto forwarding*](api::UserSettingUpdateAutoForwardingCall), [*settings update imap*](api::UserSettingUpdateImapCall), [*settings update language*](api::UserSettingUpdateLanguageCall), [*settings update pop*](api::UserSettingUpdatePopCall), [*settings update vacation*](api::UserSettingUpdateVacationCall), [*stop*](api::UserStopCall), [*threads delete*](api::UserThreadDeleteCall), [*threads get*](api::UserThreadGetCall), [*threads list*](api::UserThreadListCall), [*threads modify*](api::UserThreadModifyCall), [*threads trash*](api::UserThreadTrashCall), [*threads untrash*](api::UserThreadUntrashCall) and [*watch*](api::UserWatchCall) @@ -66,8 +66,8 @@ //! let r = hub.users().messages_untrash(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -97,12 +97,12 @@ //! use std::default::Default; //! use gmail1::{Gmail, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -147,10 +147,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -160,25 +160,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/gmailpostmastertools1/src/lib.rs b/gen/gmailpostmastertools1/src/lib.rs index 93be0d9f3d..eb37473996 100644 --- a/gen/gmailpostmastertools1/src/lib.rs +++ b/gen/gmailpostmastertools1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/gmailpostmastertools1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PostmasterTools) ... +//! Handle the following *Resources* with ease from the central [hub](PostmasterTools) ... //! //! * [domains](api::Domain) //! * [*get*](api::DomainGetCall), [*list*](api::DomainListCall), [*traffic stats get*](api::DomainTrafficStatGetCall) and [*traffic stats list*](api::DomainTrafficStatListCall) @@ -53,8 +53,8 @@ //! let r = hub.domains().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use gmailpostmastertools1::{PostmasterTools, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/gmailpostmastertools1_beta1/src/lib.rs b/gen/gmailpostmastertools1_beta1/src/lib.rs index 4990f92897..7c57c57500 100644 --- a/gen/gmailpostmastertools1_beta1/src/lib.rs +++ b/gen/gmailpostmastertools1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/gmailpostmastertools1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PostmasterTools) ... +//! Handle the following *Resources* with ease from the central [hub](PostmasterTools) ... //! //! * [domains](api::Domain) //! * [*get*](api::DomainGetCall), [*list*](api::DomainListCall), [*traffic stats get*](api::DomainTrafficStatGetCall) and [*traffic stats list*](api::DomainTrafficStatListCall) @@ -53,8 +53,8 @@ //! let r = hub.domains().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use gmailpostmastertools1_beta1::{PostmasterTools, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/groupsmigration1/src/lib.rs b/gen/groupsmigration1/src/lib.rs index 4ad9ad39cd..cf14df0100 100644 --- a/gen/groupsmigration1/src/lib.rs +++ b/gen/groupsmigration1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/groupsmigration1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](GroupsMigration) ... +//! Handle the following *Resources* with ease from the central [hub](GroupsMigration) ... //! //! * archive //! * [*insert*](api::ArchiveInsertCall) @@ -54,8 +54,8 @@ //! let r = hub.archive().insert(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use groupsmigration1::{GroupsMigration, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -125,10 +125,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -138,25 +138,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/groupssettings1/src/lib.rs b/gen/groupssettings1/src/lib.rs index 7eaa3fd4c0..cdf4ec965c 100644 --- a/gen/groupssettings1/src/lib.rs +++ b/gen/groupssettings1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/groupssettings1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Groupssettings) ... +//! Handle the following *Resources* with ease from the central [hub](Groupssettings) ... //! //! * groups //! * [*get*](api::GroupGetCall), [*patch*](api::GroupPatchCall) and [*update*](api::GroupUpdateCall) @@ -52,8 +52,8 @@ //! let r = hub.groups().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use groupssettings1::{Groupssettings, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/healthcare1/src/lib.rs b/gen/healthcare1/src/lib.rs index 7e8d57e0aa..06c6f06b7b 100644 --- a/gen/healthcare1/src/lib.rs +++ b/gen/healthcare1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/healthcare1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudHealthcare) ... +//! Handle the following *Resources* with ease from the central [hub](CloudHealthcare) ... //! //! * projects //! * [*locations datasets consent stores attribute definitions create*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionCreateCall), [*locations datasets consent stores attribute definitions delete*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionDeleteCall), [*locations datasets consent stores attribute definitions get*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionGetCall), [*locations datasets consent stores attribute definitions list*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionListCall), [*locations datasets consent stores attribute definitions patch*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionPatchCall), [*locations datasets consent stores check data access*](api::ProjectLocationDatasetConsentStoreCheckDataAccesCall), [*locations datasets consent stores consent artifacts create*](api::ProjectLocationDatasetConsentStoreConsentArtifactCreateCall), [*locations datasets consent stores consent artifacts delete*](api::ProjectLocationDatasetConsentStoreConsentArtifactDeleteCall), [*locations datasets consent stores consent artifacts get*](api::ProjectLocationDatasetConsentStoreConsentArtifactGetCall), [*locations datasets consent stores consent artifacts list*](api::ProjectLocationDatasetConsentStoreConsentArtifactListCall), [*locations datasets consent stores consents activate*](api::ProjectLocationDatasetConsentStoreConsentActivateCall), [*locations datasets consent stores consents create*](api::ProjectLocationDatasetConsentStoreConsentCreateCall), [*locations datasets consent stores consents delete*](api::ProjectLocationDatasetConsentStoreConsentDeleteCall), [*locations datasets consent stores consents delete revision*](api::ProjectLocationDatasetConsentStoreConsentDeleteRevisionCall), [*locations datasets consent stores consents get*](api::ProjectLocationDatasetConsentStoreConsentGetCall), [*locations datasets consent stores consents list*](api::ProjectLocationDatasetConsentStoreConsentListCall), [*locations datasets consent stores consents list revisions*](api::ProjectLocationDatasetConsentStoreConsentListRevisionCall), [*locations datasets consent stores consents patch*](api::ProjectLocationDatasetConsentStoreConsentPatchCall), [*locations datasets consent stores consents reject*](api::ProjectLocationDatasetConsentStoreConsentRejectCall), [*locations datasets consent stores consents revoke*](api::ProjectLocationDatasetConsentStoreConsentRevokeCall), [*locations datasets consent stores create*](api::ProjectLocationDatasetConsentStoreCreateCall), [*locations datasets consent stores delete*](api::ProjectLocationDatasetConsentStoreDeleteCall), [*locations datasets consent stores evaluate user consents*](api::ProjectLocationDatasetConsentStoreEvaluateUserConsentCall), [*locations datasets consent stores get*](api::ProjectLocationDatasetConsentStoreGetCall), [*locations datasets consent stores get iam policy*](api::ProjectLocationDatasetConsentStoreGetIamPolicyCall), [*locations datasets consent stores list*](api::ProjectLocationDatasetConsentStoreListCall), [*locations datasets consent stores patch*](api::ProjectLocationDatasetConsentStorePatchCall), [*locations datasets consent stores query accessible data*](api::ProjectLocationDatasetConsentStoreQueryAccessibleDataCall), [*locations datasets consent stores set iam policy*](api::ProjectLocationDatasetConsentStoreSetIamPolicyCall), [*locations datasets consent stores test iam permissions*](api::ProjectLocationDatasetConsentStoreTestIamPermissionCall), [*locations datasets consent stores user data mappings archive*](api::ProjectLocationDatasetConsentStoreUserDataMappingArchiveCall), [*locations datasets consent stores user data mappings create*](api::ProjectLocationDatasetConsentStoreUserDataMappingCreateCall), [*locations datasets consent stores user data mappings delete*](api::ProjectLocationDatasetConsentStoreUserDataMappingDeleteCall), [*locations datasets consent stores user data mappings get*](api::ProjectLocationDatasetConsentStoreUserDataMappingGetCall), [*locations datasets consent stores user data mappings list*](api::ProjectLocationDatasetConsentStoreUserDataMappingListCall), [*locations datasets consent stores user data mappings patch*](api::ProjectLocationDatasetConsentStoreUserDataMappingPatchCall), [*locations datasets create*](api::ProjectLocationDatasetCreateCall), [*locations datasets data mapper workspaces get iam policy*](api::ProjectLocationDatasetDataMapperWorkspaceGetIamPolicyCall), [*locations datasets data mapper workspaces set iam policy*](api::ProjectLocationDatasetDataMapperWorkspaceSetIamPolicyCall), [*locations datasets data mapper workspaces test iam permissions*](api::ProjectLocationDatasetDataMapperWorkspaceTestIamPermissionCall), [*locations datasets deidentify*](api::ProjectLocationDatasetDeidentifyCall), [*locations datasets delete*](api::ProjectLocationDatasetDeleteCall), [*locations datasets dicom stores create*](api::ProjectLocationDatasetDicomStoreCreateCall), [*locations datasets dicom stores deidentify*](api::ProjectLocationDatasetDicomStoreDeidentifyCall), [*locations datasets dicom stores delete*](api::ProjectLocationDatasetDicomStoreDeleteCall), [*locations datasets dicom stores dicom web studies get study metrics*](api::ProjectLocationDatasetDicomStoreDicomWebStudyGetStudyMetricCall), [*locations datasets dicom stores dicom web studies series get series metrics*](api::ProjectLocationDatasetDicomStoreDicomWebStudySeriesGetSeriesMetricCall), [*locations datasets dicom stores export*](api::ProjectLocationDatasetDicomStoreExportCall), [*locations datasets dicom stores get*](api::ProjectLocationDatasetDicomStoreGetCall), [*locations datasets dicom stores get dicom store metrics*](api::ProjectLocationDatasetDicomStoreGetDICOMStoreMetricCall), [*locations datasets dicom stores get iam policy*](api::ProjectLocationDatasetDicomStoreGetIamPolicyCall), [*locations datasets dicom stores import*](api::ProjectLocationDatasetDicomStoreImportCall), [*locations datasets dicom stores list*](api::ProjectLocationDatasetDicomStoreListCall), [*locations datasets dicom stores patch*](api::ProjectLocationDatasetDicomStorePatchCall), [*locations datasets dicom stores search for instances*](api::ProjectLocationDatasetDicomStoreSearchForInstanceCall), [*locations datasets dicom stores search for series*](api::ProjectLocationDatasetDicomStoreSearchForSeryCall), [*locations datasets dicom stores search for studies*](api::ProjectLocationDatasetDicomStoreSearchForStudyCall), [*locations datasets dicom stores set iam policy*](api::ProjectLocationDatasetDicomStoreSetIamPolicyCall), [*locations datasets dicom stores store instances*](api::ProjectLocationDatasetDicomStoreStoreInstanceCall), [*locations datasets dicom stores studies delete*](api::ProjectLocationDatasetDicomStoreStudyDeleteCall), [*locations datasets dicom stores studies retrieve metadata*](api::ProjectLocationDatasetDicomStoreStudyRetrieveMetadataCall), [*locations datasets dicom stores studies retrieve study*](api::ProjectLocationDatasetDicomStoreStudyRetrieveStudyCall), [*locations datasets dicom stores studies search for instances*](api::ProjectLocationDatasetDicomStoreStudySearchForInstanceCall), [*locations datasets dicom stores studies search for series*](api::ProjectLocationDatasetDicomStoreStudySearchForSeryCall), [*locations datasets dicom stores studies series delete*](api::ProjectLocationDatasetDicomStoreStudySeriesDeleteCall), [*locations datasets dicom stores studies series instances delete*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceDeleteCall), [*locations datasets dicom stores studies series instances frames retrieve frames*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceFrameRetrieveFrameCall), [*locations datasets dicom stores studies series instances frames retrieve rendered*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceFrameRetrieveRenderedCall), [*locations datasets dicom stores studies series instances retrieve instance*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceRetrieveInstanceCall), [*locations datasets dicom stores studies series instances retrieve metadata*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceRetrieveMetadataCall), [*locations datasets dicom stores studies series instances retrieve rendered*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceRetrieveRenderedCall), [*locations datasets dicom stores studies series retrieve metadata*](api::ProjectLocationDatasetDicomStoreStudySeriesRetrieveMetadataCall), [*locations datasets dicom stores studies series retrieve series*](api::ProjectLocationDatasetDicomStoreStudySeriesRetrieveSeryCall), [*locations datasets dicom stores studies series search for instances*](api::ProjectLocationDatasetDicomStoreStudySeriesSearchForInstanceCall), [*locations datasets dicom stores studies store instances*](api::ProjectLocationDatasetDicomStoreStudyStoreInstanceCall), [*locations datasets dicom stores test iam permissions*](api::ProjectLocationDatasetDicomStoreTestIamPermissionCall), [*locations datasets fhir stores create*](api::ProjectLocationDatasetFhirStoreCreateCall), [*locations datasets fhir stores deidentify*](api::ProjectLocationDatasetFhirStoreDeidentifyCall), [*locations datasets fhir stores delete*](api::ProjectLocationDatasetFhirStoreDeleteCall), [*locations datasets fhir stores export*](api::ProjectLocationDatasetFhirStoreExportCall), [*locations datasets fhir stores fhir patient-everything*](api::ProjectLocationDatasetFhirStoreFhirPatientEverythingCall), [*locations datasets fhir stores fhir resource-purge*](api::ProjectLocationDatasetFhirStoreFhirResourcePurgeCall), [*locations datasets fhir stores fhir resource-validate*](api::ProjectLocationDatasetFhirStoreFhirResourceValidateCall), [*locations datasets fhir stores fhir capabilities*](api::ProjectLocationDatasetFhirStoreFhirCapabilityCall), [*locations datasets fhir stores fhir conditional delete*](api::ProjectLocationDatasetFhirStoreFhirConditionalDeleteCall), [*locations datasets fhir stores fhir conditional patch*](api::ProjectLocationDatasetFhirStoreFhirConditionalPatchCall), [*locations datasets fhir stores fhir conditional update*](api::ProjectLocationDatasetFhirStoreFhirConditionalUpdateCall), [*locations datasets fhir stores fhir create*](api::ProjectLocationDatasetFhirStoreFhirCreateCall), [*locations datasets fhir stores fhir delete*](api::ProjectLocationDatasetFhirStoreFhirDeleteCall), [*locations datasets fhir stores fhir execute bundle*](api::ProjectLocationDatasetFhirStoreFhirExecuteBundleCall), [*locations datasets fhir stores fhir history*](api::ProjectLocationDatasetFhirStoreFhirHistoryCall), [*locations datasets fhir stores fhir patch*](api::ProjectLocationDatasetFhirStoreFhirPatchCall), [*locations datasets fhir stores fhir read*](api::ProjectLocationDatasetFhirStoreFhirReadCall), [*locations datasets fhir stores fhir search*](api::ProjectLocationDatasetFhirStoreFhirSearchCall), [*locations datasets fhir stores fhir search-type*](api::ProjectLocationDatasetFhirStoreFhirSearchTypeCall), [*locations datasets fhir stores fhir update*](api::ProjectLocationDatasetFhirStoreFhirUpdateCall), [*locations datasets fhir stores fhir vread*](api::ProjectLocationDatasetFhirStoreFhirVreadCall), [*locations datasets fhir stores get*](api::ProjectLocationDatasetFhirStoreGetCall), [*locations datasets fhir stores get fhir store metrics*](api::ProjectLocationDatasetFhirStoreGetFHIRStoreMetricCall), [*locations datasets fhir stores get iam policy*](api::ProjectLocationDatasetFhirStoreGetIamPolicyCall), [*locations datasets fhir stores import*](api::ProjectLocationDatasetFhirStoreImportCall), [*locations datasets fhir stores list*](api::ProjectLocationDatasetFhirStoreListCall), [*locations datasets fhir stores patch*](api::ProjectLocationDatasetFhirStorePatchCall), [*locations datasets fhir stores rollback*](api::ProjectLocationDatasetFhirStoreRollbackCall), [*locations datasets fhir stores set iam policy*](api::ProjectLocationDatasetFhirStoreSetIamPolicyCall), [*locations datasets fhir stores test iam permissions*](api::ProjectLocationDatasetFhirStoreTestIamPermissionCall), [*locations datasets get*](api::ProjectLocationDatasetGetCall), [*locations datasets get iam policy*](api::ProjectLocationDatasetGetIamPolicyCall), [*locations datasets hl7 v2 stores create*](api::ProjectLocationDatasetHl7V2StoreCreateCall), [*locations datasets hl7 v2 stores delete*](api::ProjectLocationDatasetHl7V2StoreDeleteCall), [*locations datasets hl7 v2 stores export*](api::ProjectLocationDatasetHl7V2StoreExportCall), [*locations datasets hl7 v2 stores get*](api::ProjectLocationDatasetHl7V2StoreGetCall), [*locations datasets hl7 v2 stores get hl7v2 store metrics*](api::ProjectLocationDatasetHl7V2StoreGetHL7v2StoreMetricCall), [*locations datasets hl7 v2 stores get iam policy*](api::ProjectLocationDatasetHl7V2StoreGetIamPolicyCall), [*locations datasets hl7 v2 stores import*](api::ProjectLocationDatasetHl7V2StoreImportCall), [*locations datasets hl7 v2 stores list*](api::ProjectLocationDatasetHl7V2StoreListCall), [*locations datasets hl7 v2 stores messages create*](api::ProjectLocationDatasetHl7V2StoreMessageCreateCall), [*locations datasets hl7 v2 stores messages delete*](api::ProjectLocationDatasetHl7V2StoreMessageDeleteCall), [*locations datasets hl7 v2 stores messages get*](api::ProjectLocationDatasetHl7V2StoreMessageGetCall), [*locations datasets hl7 v2 stores messages ingest*](api::ProjectLocationDatasetHl7V2StoreMessageIngestCall), [*locations datasets hl7 v2 stores messages list*](api::ProjectLocationDatasetHl7V2StoreMessageListCall), [*locations datasets hl7 v2 stores messages patch*](api::ProjectLocationDatasetHl7V2StoreMessagePatchCall), [*locations datasets hl7 v2 stores patch*](api::ProjectLocationDatasetHl7V2StorePatchCall), [*locations datasets hl7 v2 stores set iam policy*](api::ProjectLocationDatasetHl7V2StoreSetIamPolicyCall), [*locations datasets hl7 v2 stores test iam permissions*](api::ProjectLocationDatasetHl7V2StoreTestIamPermissionCall), [*locations datasets list*](api::ProjectLocationDatasetListCall), [*locations datasets operations cancel*](api::ProjectLocationDatasetOperationCancelCall), [*locations datasets operations get*](api::ProjectLocationDatasetOperationGetCall), [*locations datasets operations list*](api::ProjectLocationDatasetOperationListCall), [*locations datasets patch*](api::ProjectLocationDatasetPatchCall), [*locations datasets set iam policy*](api::ProjectLocationDatasetSetIamPolicyCall), [*locations datasets test iam permissions*](api::ProjectLocationDatasetTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall) and [*locations services nlp analyze entities*](api::ProjectLocationServiceNlpAnalyzeEntityCall) @@ -81,8 +81,8 @@ //! let r = hub.projects().locations_datasets_fhir_stores_fhir_vread(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -110,12 +110,12 @@ //! use std::default::Default; //! use healthcare1::{CloudHealthcare, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -157,10 +157,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -170,25 +170,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/healthcare1_beta1/src/lib.rs b/gen/healthcare1_beta1/src/lib.rs index 49bef323b8..87a0a2c0c2 100644 --- a/gen/healthcare1_beta1/src/lib.rs +++ b/gen/healthcare1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/healthcare1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudHealthcare) ... +//! Handle the following *Resources* with ease from the central [hub](CloudHealthcare) ... //! //! * projects //! * [*locations datasets annotation stores annotations create*](api::ProjectLocationDatasetAnnotationStoreAnnotationCreateCall), [*locations datasets annotation stores annotations delete*](api::ProjectLocationDatasetAnnotationStoreAnnotationDeleteCall), [*locations datasets annotation stores annotations get*](api::ProjectLocationDatasetAnnotationStoreAnnotationGetCall), [*locations datasets annotation stores annotations list*](api::ProjectLocationDatasetAnnotationStoreAnnotationListCall), [*locations datasets annotation stores annotations patch*](api::ProjectLocationDatasetAnnotationStoreAnnotationPatchCall), [*locations datasets annotation stores create*](api::ProjectLocationDatasetAnnotationStoreCreateCall), [*locations datasets annotation stores delete*](api::ProjectLocationDatasetAnnotationStoreDeleteCall), [*locations datasets annotation stores evaluate*](api::ProjectLocationDatasetAnnotationStoreEvaluateCall), [*locations datasets annotation stores export*](api::ProjectLocationDatasetAnnotationStoreExportCall), [*locations datasets annotation stores get*](api::ProjectLocationDatasetAnnotationStoreGetCall), [*locations datasets annotation stores get iam policy*](api::ProjectLocationDatasetAnnotationStoreGetIamPolicyCall), [*locations datasets annotation stores import*](api::ProjectLocationDatasetAnnotationStoreImportCall), [*locations datasets annotation stores list*](api::ProjectLocationDatasetAnnotationStoreListCall), [*locations datasets annotation stores patch*](api::ProjectLocationDatasetAnnotationStorePatchCall), [*locations datasets annotation stores set iam policy*](api::ProjectLocationDatasetAnnotationStoreSetIamPolicyCall), [*locations datasets annotation stores test iam permissions*](api::ProjectLocationDatasetAnnotationStoreTestIamPermissionCall), [*locations datasets consent stores attribute definitions create*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionCreateCall), [*locations datasets consent stores attribute definitions delete*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionDeleteCall), [*locations datasets consent stores attribute definitions get*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionGetCall), [*locations datasets consent stores attribute definitions list*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionListCall), [*locations datasets consent stores attribute definitions patch*](api::ProjectLocationDatasetConsentStoreAttributeDefinitionPatchCall), [*locations datasets consent stores check data access*](api::ProjectLocationDatasetConsentStoreCheckDataAccesCall), [*locations datasets consent stores consent artifacts create*](api::ProjectLocationDatasetConsentStoreConsentArtifactCreateCall), [*locations datasets consent stores consent artifacts delete*](api::ProjectLocationDatasetConsentStoreConsentArtifactDeleteCall), [*locations datasets consent stores consent artifacts get*](api::ProjectLocationDatasetConsentStoreConsentArtifactGetCall), [*locations datasets consent stores consent artifacts list*](api::ProjectLocationDatasetConsentStoreConsentArtifactListCall), [*locations datasets consent stores consents activate*](api::ProjectLocationDatasetConsentStoreConsentActivateCall), [*locations datasets consent stores consents create*](api::ProjectLocationDatasetConsentStoreConsentCreateCall), [*locations datasets consent stores consents delete*](api::ProjectLocationDatasetConsentStoreConsentDeleteCall), [*locations datasets consent stores consents delete revision*](api::ProjectLocationDatasetConsentStoreConsentDeleteRevisionCall), [*locations datasets consent stores consents get*](api::ProjectLocationDatasetConsentStoreConsentGetCall), [*locations datasets consent stores consents list*](api::ProjectLocationDatasetConsentStoreConsentListCall), [*locations datasets consent stores consents list revisions*](api::ProjectLocationDatasetConsentStoreConsentListRevisionCall), [*locations datasets consent stores consents patch*](api::ProjectLocationDatasetConsentStoreConsentPatchCall), [*locations datasets consent stores consents reject*](api::ProjectLocationDatasetConsentStoreConsentRejectCall), [*locations datasets consent stores consents revoke*](api::ProjectLocationDatasetConsentStoreConsentRevokeCall), [*locations datasets consent stores create*](api::ProjectLocationDatasetConsentStoreCreateCall), [*locations datasets consent stores delete*](api::ProjectLocationDatasetConsentStoreDeleteCall), [*locations datasets consent stores evaluate user consents*](api::ProjectLocationDatasetConsentStoreEvaluateUserConsentCall), [*locations datasets consent stores get*](api::ProjectLocationDatasetConsentStoreGetCall), [*locations datasets consent stores get iam policy*](api::ProjectLocationDatasetConsentStoreGetIamPolicyCall), [*locations datasets consent stores list*](api::ProjectLocationDatasetConsentStoreListCall), [*locations datasets consent stores patch*](api::ProjectLocationDatasetConsentStorePatchCall), [*locations datasets consent stores query accessible data*](api::ProjectLocationDatasetConsentStoreQueryAccessibleDataCall), [*locations datasets consent stores set iam policy*](api::ProjectLocationDatasetConsentStoreSetIamPolicyCall), [*locations datasets consent stores test iam permissions*](api::ProjectLocationDatasetConsentStoreTestIamPermissionCall), [*locations datasets consent stores user data mappings archive*](api::ProjectLocationDatasetConsentStoreUserDataMappingArchiveCall), [*locations datasets consent stores user data mappings create*](api::ProjectLocationDatasetConsentStoreUserDataMappingCreateCall), [*locations datasets consent stores user data mappings delete*](api::ProjectLocationDatasetConsentStoreUserDataMappingDeleteCall), [*locations datasets consent stores user data mappings get*](api::ProjectLocationDatasetConsentStoreUserDataMappingGetCall), [*locations datasets consent stores user data mappings list*](api::ProjectLocationDatasetConsentStoreUserDataMappingListCall), [*locations datasets consent stores user data mappings patch*](api::ProjectLocationDatasetConsentStoreUserDataMappingPatchCall), [*locations datasets create*](api::ProjectLocationDatasetCreateCall), [*locations datasets data mapper workspaces get iam policy*](api::ProjectLocationDatasetDataMapperWorkspaceGetIamPolicyCall), [*locations datasets data mapper workspaces set iam policy*](api::ProjectLocationDatasetDataMapperWorkspaceSetIamPolicyCall), [*locations datasets data mapper workspaces test iam permissions*](api::ProjectLocationDatasetDataMapperWorkspaceTestIamPermissionCall), [*locations datasets deidentify*](api::ProjectLocationDatasetDeidentifyCall), [*locations datasets delete*](api::ProjectLocationDatasetDeleteCall), [*locations datasets dicom stores create*](api::ProjectLocationDatasetDicomStoreCreateCall), [*locations datasets dicom stores deidentify*](api::ProjectLocationDatasetDicomStoreDeidentifyCall), [*locations datasets dicom stores delete*](api::ProjectLocationDatasetDicomStoreDeleteCall), [*locations datasets dicom stores dicom web studies get study metrics*](api::ProjectLocationDatasetDicomStoreDicomWebStudyGetStudyMetricCall), [*locations datasets dicom stores dicom web studies series get series metrics*](api::ProjectLocationDatasetDicomStoreDicomWebStudySeriesGetSeriesMetricCall), [*locations datasets dicom stores dicom web studies series instances get storage info*](api::ProjectLocationDatasetDicomStoreDicomWebStudySeriesInstanceGetStorageInfoCall), [*locations datasets dicom stores dicom web studies set blob storage settings*](api::ProjectLocationDatasetDicomStoreDicomWebStudySetBlobStorageSettingCall), [*locations datasets dicom stores export*](api::ProjectLocationDatasetDicomStoreExportCall), [*locations datasets dicom stores get*](api::ProjectLocationDatasetDicomStoreGetCall), [*locations datasets dicom stores get dicom store metrics*](api::ProjectLocationDatasetDicomStoreGetDICOMStoreMetricCall), [*locations datasets dicom stores get iam policy*](api::ProjectLocationDatasetDicomStoreGetIamPolicyCall), [*locations datasets dicom stores import*](api::ProjectLocationDatasetDicomStoreImportCall), [*locations datasets dicom stores list*](api::ProjectLocationDatasetDicomStoreListCall), [*locations datasets dicom stores patch*](api::ProjectLocationDatasetDicomStorePatchCall), [*locations datasets dicom stores search for instances*](api::ProjectLocationDatasetDicomStoreSearchForInstanceCall), [*locations datasets dicom stores search for series*](api::ProjectLocationDatasetDicomStoreSearchForSeryCall), [*locations datasets dicom stores search for studies*](api::ProjectLocationDatasetDicomStoreSearchForStudyCall), [*locations datasets dicom stores set blob storage settings*](api::ProjectLocationDatasetDicomStoreSetBlobStorageSettingCall), [*locations datasets dicom stores set iam policy*](api::ProjectLocationDatasetDicomStoreSetIamPolicyCall), [*locations datasets dicom stores store instances*](api::ProjectLocationDatasetDicomStoreStoreInstanceCall), [*locations datasets dicom stores studies delete*](api::ProjectLocationDatasetDicomStoreStudyDeleteCall), [*locations datasets dicom stores studies retrieve metadata*](api::ProjectLocationDatasetDicomStoreStudyRetrieveMetadataCall), [*locations datasets dicom stores studies retrieve study*](api::ProjectLocationDatasetDicomStoreStudyRetrieveStudyCall), [*locations datasets dicom stores studies search for instances*](api::ProjectLocationDatasetDicomStoreStudySearchForInstanceCall), [*locations datasets dicom stores studies search for series*](api::ProjectLocationDatasetDicomStoreStudySearchForSeryCall), [*locations datasets dicom stores studies series delete*](api::ProjectLocationDatasetDicomStoreStudySeriesDeleteCall), [*locations datasets dicom stores studies series instances bulkdata retrieve bulkdata*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceBulkdataRetrieveBulkdataCall), [*locations datasets dicom stores studies series instances delete*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceDeleteCall), [*locations datasets dicom stores studies series instances frames retrieve frames*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceFrameRetrieveFrameCall), [*locations datasets dicom stores studies series instances frames retrieve rendered*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceFrameRetrieveRenderedCall), [*locations datasets dicom stores studies series instances retrieve instance*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceRetrieveInstanceCall), [*locations datasets dicom stores studies series instances retrieve metadata*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceRetrieveMetadataCall), [*locations datasets dicom stores studies series instances retrieve rendered*](api::ProjectLocationDatasetDicomStoreStudySeriesInstanceRetrieveRenderedCall), [*locations datasets dicom stores studies series retrieve metadata*](api::ProjectLocationDatasetDicomStoreStudySeriesRetrieveMetadataCall), [*locations datasets dicom stores studies series retrieve series*](api::ProjectLocationDatasetDicomStoreStudySeriesRetrieveSeryCall), [*locations datasets dicom stores studies series search for instances*](api::ProjectLocationDatasetDicomStoreStudySeriesSearchForInstanceCall), [*locations datasets dicom stores studies store instances*](api::ProjectLocationDatasetDicomStoreStudyStoreInstanceCall), [*locations datasets dicom stores test iam permissions*](api::ProjectLocationDatasetDicomStoreTestIamPermissionCall), [*locations datasets fhir stores apply admin consents*](api::ProjectLocationDatasetFhirStoreApplyAdminConsentCall), [*locations datasets fhir stores apply consents*](api::ProjectLocationDatasetFhirStoreApplyConsentCall), [*locations datasets fhir stores configure search*](api::ProjectLocationDatasetFhirStoreConfigureSearchCall), [*locations datasets fhir stores create*](api::ProjectLocationDatasetFhirStoreCreateCall), [*locations datasets fhir stores deidentify*](api::ProjectLocationDatasetFhirStoreDeidentifyCall), [*locations datasets fhir stores delete*](api::ProjectLocationDatasetFhirStoreDeleteCall), [*locations datasets fhir stores explain data access*](api::ProjectLocationDatasetFhirStoreExplainDataAccesCall), [*locations datasets fhir stores export*](api::ProjectLocationDatasetFhirStoreExportCall), [*locations datasets fhir stores fhir concept map-search-translate*](api::ProjectLocationDatasetFhirStoreFhirConceptMapSearchTranslateCall), [*locations datasets fhir stores fhir concept map-translate*](api::ProjectLocationDatasetFhirStoreFhirConceptMapTranslateCall), [*locations datasets fhir stores fhir consent-enforcement-status*](api::ProjectLocationDatasetFhirStoreFhirConsentEnforcementStatuCall), [*locations datasets fhir stores fhir observation-lastn*](api::ProjectLocationDatasetFhirStoreFhirObservationLastnCall), [*locations datasets fhir stores fhir patient-consent-enforcement-status*](api::ProjectLocationDatasetFhirStoreFhirPatientConsentEnforcementStatuCall), [*locations datasets fhir stores fhir patient-everything*](api::ProjectLocationDatasetFhirStoreFhirPatientEverythingCall), [*locations datasets fhir stores fhir resource-incoming-references*](api::ProjectLocationDatasetFhirStoreFhirResourceIncomingReferenceCall), [*locations datasets fhir stores fhir resource-purge*](api::ProjectLocationDatasetFhirStoreFhirResourcePurgeCall), [*locations datasets fhir stores fhir resource-validate*](api::ProjectLocationDatasetFhirStoreFhirResourceValidateCall), [*locations datasets fhir stores fhir capabilities*](api::ProjectLocationDatasetFhirStoreFhirCapabilityCall), [*locations datasets fhir stores fhir conditional delete*](api::ProjectLocationDatasetFhirStoreFhirConditionalDeleteCall), [*locations datasets fhir stores fhir conditional patch*](api::ProjectLocationDatasetFhirStoreFhirConditionalPatchCall), [*locations datasets fhir stores fhir conditional update*](api::ProjectLocationDatasetFhirStoreFhirConditionalUpdateCall), [*locations datasets fhir stores fhir create*](api::ProjectLocationDatasetFhirStoreFhirCreateCall), [*locations datasets fhir stores fhir delete*](api::ProjectLocationDatasetFhirStoreFhirDeleteCall), [*locations datasets fhir stores fhir execute bundle*](api::ProjectLocationDatasetFhirStoreFhirExecuteBundleCall), [*locations datasets fhir stores fhir history*](api::ProjectLocationDatasetFhirStoreFhirHistoryCall), [*locations datasets fhir stores fhir patch*](api::ProjectLocationDatasetFhirStoreFhirPatchCall), [*locations datasets fhir stores fhir read*](api::ProjectLocationDatasetFhirStoreFhirReadCall), [*locations datasets fhir stores fhir search*](api::ProjectLocationDatasetFhirStoreFhirSearchCall), [*locations datasets fhir stores fhir search-type*](api::ProjectLocationDatasetFhirStoreFhirSearchTypeCall), [*locations datasets fhir stores fhir update*](api::ProjectLocationDatasetFhirStoreFhirUpdateCall), [*locations datasets fhir stores fhir vread*](api::ProjectLocationDatasetFhirStoreFhirVreadCall), [*locations datasets fhir stores get*](api::ProjectLocationDatasetFhirStoreGetCall), [*locations datasets fhir stores get fhir store metrics*](api::ProjectLocationDatasetFhirStoreGetFHIRStoreMetricCall), [*locations datasets fhir stores get iam policy*](api::ProjectLocationDatasetFhirStoreGetIamPolicyCall), [*locations datasets fhir stores import*](api::ProjectLocationDatasetFhirStoreImportCall), [*locations datasets fhir stores list*](api::ProjectLocationDatasetFhirStoreListCall), [*locations datasets fhir stores patch*](api::ProjectLocationDatasetFhirStorePatchCall), [*locations datasets fhir stores rollback*](api::ProjectLocationDatasetFhirStoreRollbackCall), [*locations datasets fhir stores set iam policy*](api::ProjectLocationDatasetFhirStoreSetIamPolicyCall), [*locations datasets fhir stores test iam permissions*](api::ProjectLocationDatasetFhirStoreTestIamPermissionCall), [*locations datasets get*](api::ProjectLocationDatasetGetCall), [*locations datasets get iam policy*](api::ProjectLocationDatasetGetIamPolicyCall), [*locations datasets hl7 v2 stores create*](api::ProjectLocationDatasetHl7V2StoreCreateCall), [*locations datasets hl7 v2 stores delete*](api::ProjectLocationDatasetHl7V2StoreDeleteCall), [*locations datasets hl7 v2 stores export*](api::ProjectLocationDatasetHl7V2StoreExportCall), [*locations datasets hl7 v2 stores get*](api::ProjectLocationDatasetHl7V2StoreGetCall), [*locations datasets hl7 v2 stores get hl7v2 store metrics*](api::ProjectLocationDatasetHl7V2StoreGetHL7v2StoreMetricCall), [*locations datasets hl7 v2 stores get iam policy*](api::ProjectLocationDatasetHl7V2StoreGetIamPolicyCall), [*locations datasets hl7 v2 stores import*](api::ProjectLocationDatasetHl7V2StoreImportCall), [*locations datasets hl7 v2 stores list*](api::ProjectLocationDatasetHl7V2StoreListCall), [*locations datasets hl7 v2 stores messages batch get*](api::ProjectLocationDatasetHl7V2StoreMessageBatchGetCall), [*locations datasets hl7 v2 stores messages create*](api::ProjectLocationDatasetHl7V2StoreMessageCreateCall), [*locations datasets hl7 v2 stores messages delete*](api::ProjectLocationDatasetHl7V2StoreMessageDeleteCall), [*locations datasets hl7 v2 stores messages get*](api::ProjectLocationDatasetHl7V2StoreMessageGetCall), [*locations datasets hl7 v2 stores messages ingest*](api::ProjectLocationDatasetHl7V2StoreMessageIngestCall), [*locations datasets hl7 v2 stores messages list*](api::ProjectLocationDatasetHl7V2StoreMessageListCall), [*locations datasets hl7 v2 stores messages patch*](api::ProjectLocationDatasetHl7V2StoreMessagePatchCall), [*locations datasets hl7 v2 stores patch*](api::ProjectLocationDatasetHl7V2StorePatchCall), [*locations datasets hl7 v2 stores set iam policy*](api::ProjectLocationDatasetHl7V2StoreSetIamPolicyCall), [*locations datasets hl7 v2 stores test iam permissions*](api::ProjectLocationDatasetHl7V2StoreTestIamPermissionCall), [*locations datasets list*](api::ProjectLocationDatasetListCall), [*locations datasets operations cancel*](api::ProjectLocationDatasetOperationCancelCall), [*locations datasets operations get*](api::ProjectLocationDatasetOperationGetCall), [*locations datasets operations list*](api::ProjectLocationDatasetOperationListCall), [*locations datasets patch*](api::ProjectLocationDatasetPatchCall), [*locations datasets set iam policy*](api::ProjectLocationDatasetSetIamPolicyCall), [*locations datasets test iam permissions*](api::ProjectLocationDatasetTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall) and [*locations services nlp analyze entities*](api::ProjectLocationServiceNlpAnalyzeEntityCall) @@ -88,8 +88,8 @@ //! let r = hub.projects().locations_datasets_fhir_stores_fhir_vread(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -117,12 +117,12 @@ //! use std::default::Default; //! use healthcare1_beta1::{CloudHealthcare, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -164,10 +164,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -177,25 +177,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/iam1/src/lib.rs b/gen/iam1/src/lib.rs index 29b753b10e..0d877a9a96 100644 --- a/gen/iam1/src/lib.rs +++ b/gen/iam1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/iam1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Iam) ... +//! Handle the following *Resources* with ease from the central [hub](Iam) ... //! //! * iam policies //! * [*lint policy*](api::IamPolicyLintPolicyCall) and [*query auditable services*](api::IamPolicyQueryAuditableServiceCall) @@ -93,8 +93,8 @@ //! let r = hub.projects().locations_workload_identity_pools_undelete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -123,12 +123,12 @@ //! use std::default::Default; //! use iam1::{Iam, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -170,10 +170,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -183,25 +183,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/iamcredentials1/src/lib.rs b/gen/iamcredentials1/src/lib.rs index 5ea6214b3a..abef47909f 100644 --- a/gen/iamcredentials1/src/lib.rs +++ b/gen/iamcredentials1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/iamcredentials1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](IAMCredentials) ... +//! Handle the following *Resources* with ease from the central [hub](IAMCredentials) ... //! //! * projects //! * [*service accounts generate access token*](api::ProjectServiceAccountGenerateAccessTokenCall), [*service accounts generate id token*](api::ProjectServiceAccountGenerateIdTokenCall), [*service accounts sign blob*](api::ProjectServiceAccountSignBlobCall) and [*service accounts sign jwt*](api::ProjectServiceAccountSignJwtCall) @@ -50,8 +50,8 @@ //! let r = hub.projects().service_accounts_generate_access_token(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use iamcredentials1::{IAMCredentials, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/iap1/src/lib.rs b/gen/iap1/src/lib.rs index dd84d2c5e1..e470ecad73 100644 --- a/gen/iap1/src/lib.rs +++ b/gen/iap1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/iap1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudIAP) ... +//! Handle the following *Resources* with ease from the central [hub](CloudIAP) ... //! //! * projects //! * [*brands create*](api::ProjectBrandCreateCall), [*brands get*](api::ProjectBrandGetCall), [*brands identity aware proxy clients create*](api::ProjectBrandIdentityAwareProxyClientCreateCall), [*brands identity aware proxy clients delete*](api::ProjectBrandIdentityAwareProxyClientDeleteCall), [*brands identity aware proxy clients get*](api::ProjectBrandIdentityAwareProxyClientGetCall), [*brands identity aware proxy clients list*](api::ProjectBrandIdentityAwareProxyClientListCall), [*brands identity aware proxy clients reset secret*](api::ProjectBrandIdentityAwareProxyClientResetSecretCall), [*brands list*](api::ProjectBrandListCall), [*iap_tunnel locations dest groups create*](api::ProjectIapTunnelLocationDestGroupCreateCall), [*iap_tunnel locations dest groups delete*](api::ProjectIapTunnelLocationDestGroupDeleteCall), [*iap_tunnel locations dest groups get*](api::ProjectIapTunnelLocationDestGroupGetCall), [*iap_tunnel locations dest groups list*](api::ProjectIapTunnelLocationDestGroupListCall) and [*iap_tunnel locations dest groups patch*](api::ProjectIapTunnelLocationDestGroupPatchCall) @@ -60,8 +60,8 @@ //! let r = hub.projects().brands_identity_aware_proxy_clients_reset_secret(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use iap1::{CloudIAP, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/iap1_beta1/src/lib.rs b/gen/iap1_beta1/src/lib.rs index 828d8ea648..e109b91a2b 100644 --- a/gen/iap1_beta1/src/lib.rs +++ b/gen/iap1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/iap1_beta1). //! # Features //! -//! Use the following functionality with ease from the central [hub](CloudIAP) ... +//! Use the following functionality with ease from the central [hub](CloudIAP) ... //! //! //! * [get iam policy](api::MethodGetIamPolicyCall) @@ -52,8 +52,8 @@ //! let r = hub.methods().set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use iap1_beta1::{CloudIAP, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/ideahub1_beta/src/api.rs b/gen/ideahub1_beta/src/api.rs index 5277acb034..96d211d975 100644 --- a/gen/ideahub1_beta/src/api.rs +++ b/gen/ideahub1_beta/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/ideahub1_beta/src/lib.rs b/gen/ideahub1_beta/src/lib.rs index 8a8852ec28..8b5bff3553 100644 --- a/gen/ideahub1_beta/src/lib.rs +++ b/gen/ideahub1_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/ideahub1_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Ideahub) ... +//! Handle the following *Resources* with ease from the central [hub](Ideahub) ... //! //! * platforms //! * [*properties idea activities create*](api::PlatformPropertyIdeaActivityCreateCall), [*properties idea states patch*](api::PlatformPropertyIdeaStatePatchCall), [*properties ideas list*](api::PlatformPropertyIdeaListCall), [*properties locales list*](api::PlatformPropertyLocaleListCall) and [*properties topic states patch*](api::PlatformPropertyTopicStatePatchCall) @@ -50,8 +50,8 @@ //! let r = hub.platforms().properties_idea_activities_create(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use ideahub1_beta::{Ideahub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/identitytoolkit3/src/lib.rs b/gen/identitytoolkit3/src/lib.rs index db466c2315..a5c21f6be0 100644 --- a/gen/identitytoolkit3/src/lib.rs +++ b/gen/identitytoolkit3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/identitytoolkit3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](IdentityToolkit) ... +//! Handle the following *Resources* with ease from the central [hub](IdentityToolkit) ... //! //! * [relyingparty](api::Relyingparty) //! * [*create auth uri*](api::RelyingpartyCreateAuthUriCall), [*delete account*](api::RelyingpartyDeleteAccountCall), [*download account*](api::RelyingpartyDownloadAccountCall), [*email link signin*](api::RelyingpartyEmailLinkSigninCall), [*get account info*](api::RelyingpartyGetAccountInfoCall), [*get oob confirmation code*](api::RelyingpartyGetOobConfirmationCodeCall), [*get project config*](api::RelyingpartyGetProjectConfigCall), [*get public keys*](api::RelyingpartyGetPublicKeyCall), [*get recaptcha param*](api::RelyingpartyGetRecaptchaParamCall), [*reset password*](api::RelyingpartyResetPasswordCall), [*send verification code*](api::RelyingpartySendVerificationCodeCall), [*set account info*](api::RelyingpartySetAccountInfoCall), [*set project config*](api::RelyingpartySetProjectConfigCall), [*sign out user*](api::RelyingpartySignOutUserCall), [*signup new user*](api::RelyingpartySignupNewUserCall), [*upload account*](api::RelyingpartyUploadAccountCall), [*verify assertion*](api::RelyingpartyVerifyAssertionCall), [*verify custom token*](api::RelyingpartyVerifyCustomTokenCall), [*verify password*](api::RelyingpartyVerifyPasswordCall) and [*verify phone number*](api::RelyingpartyVerifyPhoneNumberCall) @@ -50,8 +50,8 @@ //! let r = hub.relyingparty().verify_assertion(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use identitytoolkit3::{IdentityToolkit, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/ids1/src/lib.rs b/gen/ids1/src/lib.rs index 801989b7e6..f97d8a5526 100644 --- a/gen/ids1/src/lib.rs +++ b/gen/ids1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/ids1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](IDS) ... +//! Handle the following *Resources* with ease from the central [hub](IDS) ... //! //! * projects //! * [*locations endpoints create*](api::ProjectLocationEndpointCreateCall), [*locations endpoints delete*](api::ProjectLocationEndpointDeleteCall), [*locations endpoints get*](api::ProjectLocationEndpointGetCall), [*locations endpoints get iam policy*](api::ProjectLocationEndpointGetIamPolicyCall), [*locations endpoints list*](api::ProjectLocationEndpointListCall), [*locations endpoints patch*](api::ProjectLocationEndpointPatchCall), [*locations endpoints set iam policy*](api::ProjectLocationEndpointSetIamPolicyCall), [*locations endpoints test iam permissions*](api::ProjectLocationEndpointTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use ids1::{IDS, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/indexing3/src/lib.rs b/gen/indexing3/src/lib.rs index f4c2c4912c..fe45a0ebe7 100644 --- a/gen/indexing3/src/lib.rs +++ b/gen/indexing3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/indexing3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Indexing) ... +//! Handle the following *Resources* with ease from the central [hub](Indexing) ... //! //! * [url notifications](api::UrlNotification) //! * [*get metadata*](api::UrlNotificationGetMetadataCall) and [*publish*](api::UrlNotificationPublishCall) @@ -51,8 +51,8 @@ //! let r = hub.url_notifications().publish(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use indexing3::{Indexing, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -122,10 +122,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -135,25 +135,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/jobs3/src/lib.rs b/gen/jobs3/src/lib.rs index f72e4d904a..eb8d86fb93 100644 --- a/gen/jobs3/src/lib.rs +++ b/gen/jobs3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/jobs3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudTalentSolution) ... +//! Handle the following *Resources* with ease from the central [hub](CloudTalentSolution) ... //! //! * projects //! * [*client events create*](api::ProjectClientEventCreateCall), [*companies create*](api::ProjectCompanyCreateCall), [*companies delete*](api::ProjectCompanyDeleteCall), [*companies get*](api::ProjectCompanyGetCall), [*companies list*](api::ProjectCompanyListCall), [*companies patch*](api::ProjectCompanyPatchCall), [*complete*](api::ProjectCompleteCall), [*jobs batch delete*](api::ProjectJobBatchDeleteCall), [*jobs create*](api::ProjectJobCreateCall), [*jobs delete*](api::ProjectJobDeleteCall), [*jobs get*](api::ProjectJobGetCall), [*jobs list*](api::ProjectJobListCall), [*jobs patch*](api::ProjectJobPatchCall), [*jobs search*](api::ProjectJobSearchCall) and [*jobs search for alert*](api::ProjectJobSearchForAlertCall) @@ -52,8 +52,8 @@ //! let r = hub.projects().jobs_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use jobs3::{CloudTalentSolution, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/jobs4/src/lib.rs b/gen/jobs4/src/lib.rs index d568a96ea3..246a1c86d8 100644 --- a/gen/jobs4/src/lib.rs +++ b/gen/jobs4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/jobs4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudTalentSolution) ... +//! Handle the following *Resources* with ease from the central [hub](CloudTalentSolution) ... //! //! * projects //! * [*operations get*](api::ProjectOperationGetCall), [*tenants client events create*](api::ProjectTenantClientEventCreateCall), [*tenants companies create*](api::ProjectTenantCompanyCreateCall), [*tenants companies delete*](api::ProjectTenantCompanyDeleteCall), [*tenants companies get*](api::ProjectTenantCompanyGetCall), [*tenants companies list*](api::ProjectTenantCompanyListCall), [*tenants companies patch*](api::ProjectTenantCompanyPatchCall), [*tenants complete query*](api::ProjectTenantCompleteQueryCall), [*tenants create*](api::ProjectTenantCreateCall), [*tenants delete*](api::ProjectTenantDeleteCall), [*tenants get*](api::ProjectTenantGetCall), [*tenants jobs batch create*](api::ProjectTenantJobBatchCreateCall), [*tenants jobs batch delete*](api::ProjectTenantJobBatchDeleteCall), [*tenants jobs batch update*](api::ProjectTenantJobBatchUpdateCall), [*tenants jobs create*](api::ProjectTenantJobCreateCall), [*tenants jobs delete*](api::ProjectTenantJobDeleteCall), [*tenants jobs get*](api::ProjectTenantJobGetCall), [*tenants jobs list*](api::ProjectTenantJobListCall), [*tenants jobs patch*](api::ProjectTenantJobPatchCall), [*tenants jobs search*](api::ProjectTenantJobSearchCall), [*tenants jobs search for alert*](api::ProjectTenantJobSearchForAlertCall), [*tenants list*](api::ProjectTenantListCall) and [*tenants patch*](api::ProjectTenantPatchCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().tenants_jobs_batch_update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use jobs4::{CloudTalentSolution, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/keep1/src/lib.rs b/gen/keep1/src/lib.rs index 22f602d5cc..38353ddb5a 100644 --- a/gen/keep1/src/lib.rs +++ b/gen/keep1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/keep1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Keep) ... +//! Handle the following *Resources* with ease from the central [hub](Keep) ... //! //! * media //! * [*download*](api::MediaDownloadCall) @@ -61,8 +61,8 @@ //! let r = hub.notes().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use keep1::{Keep, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/language1/src/lib.rs b/gen/language1/src/lib.rs index 9352b874b1..73b18d27ea 100644 --- a/gen/language1/src/lib.rs +++ b/gen/language1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/language1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudNaturalLanguage) ... +//! Handle the following *Resources* with ease from the central [hub](CloudNaturalLanguage) ... //! //! * [documents](api::Document) //! * [*analyze entities*](api::DocumentAnalyzeEntityCall), [*analyze entity sentiment*](api::DocumentAnalyzeEntitySentimentCall), [*analyze sentiment*](api::DocumentAnalyzeSentimentCall), [*analyze syntax*](api::DocumentAnalyzeSyntaxCall), [*annotate text*](api::DocumentAnnotateTextCall), [*classify text*](api::DocumentClassifyTextCall) and [*moderate text*](api::DocumentModerateTextCall) @@ -56,8 +56,8 @@ //! let r = hub.documents().moderate_text(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use language1::{CloudNaturalLanguage, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/language1_beta1/src/lib.rs b/gen/language1_beta1/src/lib.rs index 6a36932e81..4ab229473f 100644 --- a/gen/language1_beta1/src/lib.rs +++ b/gen/language1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/language1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudNaturalLanguage) ... +//! Handle the following *Resources* with ease from the central [hub](CloudNaturalLanguage) ... //! //! * [documents](api::Document) //! * [*analyze entities*](api::DocumentAnalyzeEntityCall), [*analyze sentiment*](api::DocumentAnalyzeSentimentCall), [*analyze syntax*](api::DocumentAnalyzeSyntaxCall) and [*annotate text*](api::DocumentAnnotateTextCall) @@ -53,8 +53,8 @@ //! let r = hub.documents().annotate_text(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use language1_beta1::{CloudNaturalLanguage, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/libraryagent1/src/lib.rs b/gen/libraryagent1/src/lib.rs index 9273f94d2f..6dea7beae1 100644 --- a/gen/libraryagent1/src/lib.rs +++ b/gen/libraryagent1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/libraryagent1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Libraryagent) ... +//! Handle the following *Resources* with ease from the central [hub](Libraryagent) ... //! //! * shelves //! * [*books borrow*](api::ShelfBookBorrowCall), [*books get*](api::ShelfBookGetCall), [*books list*](api::ShelfBookListCall), [*books return*](api::ShelfBookReturnCall), [*get*](api::ShelfGetCall) and [*list*](api::ShelfListCall) @@ -52,8 +52,8 @@ //! let r = hub.shelves().books_return(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use libraryagent1::{Libraryagent, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -122,10 +122,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -135,25 +135,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/licensing1/src/lib.rs b/gen/licensing1/src/lib.rs index 2f2d648198..c232f257ae 100644 --- a/gen/licensing1/src/lib.rs +++ b/gen/licensing1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/licensing1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Licensing) ... +//! Handle the following *Resources* with ease from the central [hub](Licensing) ... //! //! * [license assignments](api::LicenseAssignment) //! * [*delete*](api::LicenseAssignmentDeleteCall), [*get*](api::LicenseAssignmentGetCall), [*insert*](api::LicenseAssignmentInsertCall), [*list for product*](api::LicenseAssignmentListForProductCall), [*list for product and sku*](api::LicenseAssignmentListForProductAndSkuCall), [*patch*](api::LicenseAssignmentPatchCall) and [*update*](api::LicenseAssignmentUpdateCall) @@ -56,8 +56,8 @@ //! let r = hub.license_assignments().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use licensing1::{Licensing, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/lifesciences2_beta/src/lib.rs b/gen/lifesciences2_beta/src/lib.rs index d9f1803fec..03451642ab 100644 --- a/gen/lifesciences2_beta/src/lib.rs +++ b/gen/lifesciences2_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/lifesciences2_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudLifeSciences) ... +//! Handle the following *Resources* with ease from the central [hub](CloudLifeSciences) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall) and [*locations pipelines run*](api::ProjectLocationPipelineRunCall) @@ -51,8 +51,8 @@ //! let r = hub.projects().locations_pipelines_run(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use lifesciences2_beta::{CloudLifeSciences, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/localservices1/src/lib.rs b/gen/localservices1/src/lib.rs index ad23567b7e..714483f9ef 100644 --- a/gen/localservices1/src/lib.rs +++ b/gen/localservices1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/localservices1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Localservices) ... +//! Handle the following *Resources* with ease from the central [hub](Localservices) ... //! //! * account reports //! * [*search*](api::AccountReportSearchCall) @@ -52,8 +52,8 @@ //! let r = hub.account_reports().search(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use localservices1::{Localservices, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/logging2/src/lib.rs b/gen/logging2/src/lib.rs index 4df2be4ebf..f7eede8b48 100644 --- a/gen/logging2/src/lib.rs +++ b/gen/logging2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/logging2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Logging) ... +//! Handle the following *Resources* with ease from the central [hub](Logging) ... //! //! * billing accounts //! * [*exclusions create*](api::BillingAccountExclusionCreateCall), [*exclusions delete*](api::BillingAccountExclusionDeleteCall), [*exclusions get*](api::BillingAccountExclusionGetCall), [*exclusions list*](api::BillingAccountExclusionListCall), [*exclusions patch*](api::BillingAccountExclusionPatchCall), [*get cmek settings*](api::BillingAccountGetCmekSettingCall), [*get settings*](api::BillingAccountGetSettingCall), [*locations buckets create*](api::BillingAccountLocationBucketCreateCall), [*locations buckets create async*](api::BillingAccountLocationBucketCreateAsyncCall), [*locations buckets delete*](api::BillingAccountLocationBucketDeleteCall), [*locations buckets get*](api::BillingAccountLocationBucketGetCall), [*locations buckets links create*](api::BillingAccountLocationBucketLinkCreateCall), [*locations buckets links delete*](api::BillingAccountLocationBucketLinkDeleteCall), [*locations buckets links get*](api::BillingAccountLocationBucketLinkGetCall), [*locations buckets links list*](api::BillingAccountLocationBucketLinkListCall), [*locations buckets list*](api::BillingAccountLocationBucketListCall), [*locations buckets patch*](api::BillingAccountLocationBucketPatchCall), [*locations buckets undelete*](api::BillingAccountLocationBucketUndeleteCall), [*locations buckets update async*](api::BillingAccountLocationBucketUpdateAsyncCall), [*locations buckets views create*](api::BillingAccountLocationBucketViewCreateCall), [*locations buckets views delete*](api::BillingAccountLocationBucketViewDeleteCall), [*locations buckets views get*](api::BillingAccountLocationBucketViewGetCall), [*locations buckets views list*](api::BillingAccountLocationBucketViewListCall), [*locations buckets views logs list*](api::BillingAccountLocationBucketViewLogListCall), [*locations buckets views patch*](api::BillingAccountLocationBucketViewPatchCall), [*locations get*](api::BillingAccountLocationGetCall), [*locations list*](api::BillingAccountLocationListCall), [*locations operations cancel*](api::BillingAccountLocationOperationCancelCall), [*locations operations get*](api::BillingAccountLocationOperationGetCall), [*locations operations list*](api::BillingAccountLocationOperationListCall), [*locations recent queries list*](api::BillingAccountLocationRecentQueryListCall), [*locations saved queries create*](api::BillingAccountLocationSavedQueryCreateCall), [*locations saved queries delete*](api::BillingAccountLocationSavedQueryDeleteCall), [*locations saved queries list*](api::BillingAccountLocationSavedQueryListCall), [*logs delete*](api::BillingAccountLogDeleteCall), [*logs list*](api::BillingAccountLogListCall), [*sinks create*](api::BillingAccountSinkCreateCall), [*sinks delete*](api::BillingAccountSinkDeleteCall), [*sinks get*](api::BillingAccountSinkGetCall), [*sinks list*](api::BillingAccountSinkListCall), [*sinks patch*](api::BillingAccountSinkPatchCall) and [*sinks update*](api::BillingAccountSinkUpdateCall) @@ -113,8 +113,8 @@ //! let r = hub.sinks().delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -143,12 +143,12 @@ //! use std::default::Default; //! use logging2::{Logging, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -189,10 +189,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -202,25 +202,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/logging2_beta1/src/lib.rs b/gen/logging2_beta1/src/lib.rs index b71b505951..c9ac73b603 100644 --- a/gen/logging2_beta1/src/lib.rs +++ b/gen/logging2_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/logging2_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Logging) ... +//! Handle the following *Resources* with ease from the central [hub](Logging) ... //! //! * entries //! * [*list*](api::EntryListCall) and [*write*](api::EntryWriteCall) @@ -56,8 +56,8 @@ //! let r = hub.projects().metrics_update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use logging2_beta1::{Logging, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/managedidentities1/src/lib.rs b/gen/managedidentities1/src/lib.rs index 9e61685310..2878d5e9a4 100644 --- a/gen/managedidentities1/src/lib.rs +++ b/gen/managedidentities1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/managedidentities1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ManagedServiceForMicrosoftActiveDirectoryConsumerAPI) ... +//! Handle the following *Resources* with ease from the central [hub](ManagedServiceForMicrosoftActiveDirectoryConsumerAPI) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations global domains attach trust*](api::ProjectLocationGlobalDomainAttachTrustCall), [*locations global domains backups create*](api::ProjectLocationGlobalDomainBackupCreateCall), [*locations global domains backups delete*](api::ProjectLocationGlobalDomainBackupDeleteCall), [*locations global domains backups get*](api::ProjectLocationGlobalDomainBackupGetCall), [*locations global domains backups get iam policy*](api::ProjectLocationGlobalDomainBackupGetIamPolicyCall), [*locations global domains backups list*](api::ProjectLocationGlobalDomainBackupListCall), [*locations global domains backups patch*](api::ProjectLocationGlobalDomainBackupPatchCall), [*locations global domains backups set iam policy*](api::ProjectLocationGlobalDomainBackupSetIamPolicyCall), [*locations global domains backups test iam permissions*](api::ProjectLocationGlobalDomainBackupTestIamPermissionCall), [*locations global domains check migration permission*](api::ProjectLocationGlobalDomainCheckMigrationPermissionCall), [*locations global domains create*](api::ProjectLocationGlobalDomainCreateCall), [*locations global domains delete*](api::ProjectLocationGlobalDomainDeleteCall), [*locations global domains detach trust*](api::ProjectLocationGlobalDomainDetachTrustCall), [*locations global domains disable migration*](api::ProjectLocationGlobalDomainDisableMigrationCall), [*locations global domains domain join machine*](api::ProjectLocationGlobalDomainDomainJoinMachineCall), [*locations global domains enable migration*](api::ProjectLocationGlobalDomainEnableMigrationCall), [*locations global domains extend schema*](api::ProjectLocationGlobalDomainExtendSchemaCall), [*locations global domains get*](api::ProjectLocationGlobalDomainGetCall), [*locations global domains get iam policy*](api::ProjectLocationGlobalDomainGetIamPolicyCall), [*locations global domains get ldapssettings*](api::ProjectLocationGlobalDomainGetLdapssettingCall), [*locations global domains list*](api::ProjectLocationGlobalDomainListCall), [*locations global domains patch*](api::ProjectLocationGlobalDomainPatchCall), [*locations global domains reconfigure trust*](api::ProjectLocationGlobalDomainReconfigureTrustCall), [*locations global domains reset admin password*](api::ProjectLocationGlobalDomainResetAdminPasswordCall), [*locations global domains restore*](api::ProjectLocationGlobalDomainRestoreCall), [*locations global domains set iam policy*](api::ProjectLocationGlobalDomainSetIamPolicyCall), [*locations global domains sql integrations get*](api::ProjectLocationGlobalDomainSqlIntegrationGetCall), [*locations global domains sql integrations list*](api::ProjectLocationGlobalDomainSqlIntegrationListCall), [*locations global domains test iam permissions*](api::ProjectLocationGlobalDomainTestIamPermissionCall), [*locations global domains update ldapssettings*](api::ProjectLocationGlobalDomainUpdateLdapssettingCall), [*locations global domains validate trust*](api::ProjectLocationGlobalDomainValidateTrustCall), [*locations global operations cancel*](api::ProjectLocationGlobalOperationCancelCall), [*locations global operations delete*](api::ProjectLocationGlobalOperationDeleteCall), [*locations global operations get*](api::ProjectLocationGlobalOperationGetCall), [*locations global operations list*](api::ProjectLocationGlobalOperationListCall), [*locations global peerings create*](api::ProjectLocationGlobalPeeringCreateCall), [*locations global peerings delete*](api::ProjectLocationGlobalPeeringDeleteCall), [*locations global peerings get*](api::ProjectLocationGlobalPeeringGetCall), [*locations global peerings get iam policy*](api::ProjectLocationGlobalPeeringGetIamPolicyCall), [*locations global peerings list*](api::ProjectLocationGlobalPeeringListCall), [*locations global peerings patch*](api::ProjectLocationGlobalPeeringPatchCall), [*locations global peerings set iam policy*](api::ProjectLocationGlobalPeeringSetIamPolicyCall), [*locations global peerings test iam permissions*](api::ProjectLocationGlobalPeeringTestIamPermissionCall) and [*locations list*](api::ProjectLocationListCall) @@ -68,8 +68,8 @@ //! let r = hub.projects().locations_global_peerings_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -98,12 +98,12 @@ //! use std::default::Default; //! use managedidentities1::{ManagedServiceForMicrosoftActiveDirectoryConsumerAPI, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -145,10 +145,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -158,25 +158,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/manager1_beta2/src/lib.rs b/gen/manager1_beta2/src/lib.rs index 3b7cbf0dfb..3abc8f86f3 100644 --- a/gen/manager1_beta2/src/lib.rs +++ b/gen/manager1_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/manager1_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Manager) ... +//! Handle the following *Resources* with ease from the central [hub](Manager) ... //! //! * [deployments](api::Deployment) //! * [*delete*](api::DeploymentDeleteCall), [*get*](api::DeploymentGetCall), [*insert*](api::DeploymentInsertCall) and [*list*](api::DeploymentListCall) @@ -55,8 +55,8 @@ //! let r = hub.deployments().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use manager1_beta2::{Manager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/manufacturers1/src/lib.rs b/gen/manufacturers1/src/lib.rs index 66bef6b864..435cc463cb 100644 --- a/gen/manufacturers1/src/lib.rs +++ b/gen/manufacturers1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/manufacturers1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ManufacturerCenter) ... +//! Handle the following *Resources* with ease from the central [hub](ManufacturerCenter) ... //! //! * accounts //! * [*languages product certifications delete*](api::AccountLanguageProductCertificationDeleteCall), [*languages product certifications get*](api::AccountLanguageProductCertificationGetCall), [*languages product certifications list*](api::AccountLanguageProductCertificationListCall), [*languages product certifications patch*](api::AccountLanguageProductCertificationPatchCall), [*products delete*](api::AccountProductDeleteCall), [*products get*](api::AccountProductGetCall), [*products list*](api::AccountProductListCall) and [*products update*](api::AccountProductUpdateCall) @@ -52,8 +52,8 @@ //! let r = hub.accounts().products_update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use manufacturers1::{ManufacturerCenter, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/memcache1/src/lib.rs b/gen/memcache1/src/lib.rs index ee59061e57..f5122849ce 100644 --- a/gen/memcache1/src/lib.rs +++ b/gen/memcache1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/memcache1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudMemorystoreForMemcached) ... +//! Handle the following *Resources* with ease from the central [hub](CloudMemorystoreForMemcached) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations instances apply parameters*](api::ProjectLocationInstanceApplyParameterCall), [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances patch*](api::ProjectLocationInstancePatchCall), [*locations instances reschedule maintenance*](api::ProjectLocationInstanceRescheduleMaintenanceCall), [*locations instances update parameters*](api::ProjectLocationInstanceUpdateParameterCall), [*locations instances upgrade*](api::ProjectLocationInstanceUpgradeCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -57,8 +57,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use memcache1::{CloudMemorystoreForMemcached, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/memcache1_beta2/src/lib.rs b/gen/memcache1_beta2/src/lib.rs index 67ce945bf4..c0f991a32f 100644 --- a/gen/memcache1_beta2/src/lib.rs +++ b/gen/memcache1_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/memcache1_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudMemorystoreForMemcached) ... +//! Handle the following *Resources* with ease from the central [hub](CloudMemorystoreForMemcached) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations instances apply parameters*](api::ProjectLocationInstanceApplyParameterCall), [*locations instances apply software update*](api::ProjectLocationInstanceApplySoftwareUpdateCall), [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances patch*](api::ProjectLocationInstancePatchCall), [*locations instances reschedule maintenance*](api::ProjectLocationInstanceRescheduleMaintenanceCall), [*locations instances update parameters*](api::ProjectLocationInstanceUpdateParameterCall), [*locations instances upgrade*](api::ProjectLocationInstanceUpgradeCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -58,8 +58,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use memcache1_beta2::{CloudMemorystoreForMemcached, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/metastore1_beta/src/lib.rs b/gen/metastore1_beta/src/lib.rs index 6ae480184d..8e55a69b2c 100644 --- a/gen/metastore1_beta/src/lib.rs +++ b/gen/metastore1_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/metastore1_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](DataprocMetastore) ... +//! Handle the following *Resources* with ease from the central [hub](DataprocMetastore) ... //! //! * projects //! * [*locations federations create*](api::ProjectLocationFederationCreateCall), [*locations federations delete*](api::ProjectLocationFederationDeleteCall), [*locations federations get*](api::ProjectLocationFederationGetCall), [*locations federations get iam policy*](api::ProjectLocationFederationGetIamPolicyCall), [*locations federations list*](api::ProjectLocationFederationListCall), [*locations federations patch*](api::ProjectLocationFederationPatchCall), [*locations federations set iam policy*](api::ProjectLocationFederationSetIamPolicyCall), [*locations federations test iam permissions*](api::ProjectLocationFederationTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations services alter location*](api::ProjectLocationServiceAlterLocationCall), [*locations services alter table properties*](api::ProjectLocationServiceAlterTablePropertyCall), [*locations services backups create*](api::ProjectLocationServiceBackupCreateCall), [*locations services backups delete*](api::ProjectLocationServiceBackupDeleteCall), [*locations services backups get*](api::ProjectLocationServiceBackupGetCall), [*locations services backups get iam policy*](api::ProjectLocationServiceBackupGetIamPolicyCall), [*locations services backups list*](api::ProjectLocationServiceBackupListCall), [*locations services backups set iam policy*](api::ProjectLocationServiceBackupSetIamPolicyCall), [*locations services backups test iam permissions*](api::ProjectLocationServiceBackupTestIamPermissionCall), [*locations services create*](api::ProjectLocationServiceCreateCall), [*locations services databases get iam policy*](api::ProjectLocationServiceDatabaseGetIamPolicyCall), [*locations services databases set iam policy*](api::ProjectLocationServiceDatabaseSetIamPolicyCall), [*locations services databases tables get iam policy*](api::ProjectLocationServiceDatabaseTableGetIamPolicyCall), [*locations services databases tables set iam policy*](api::ProjectLocationServiceDatabaseTableSetIamPolicyCall), [*locations services databases tables test iam permissions*](api::ProjectLocationServiceDatabaseTableTestIamPermissionCall), [*locations services databases test iam permissions*](api::ProjectLocationServiceDatabaseTestIamPermissionCall), [*locations services delete*](api::ProjectLocationServiceDeleteCall), [*locations services export metadata*](api::ProjectLocationServiceExportMetadataCall), [*locations services get*](api::ProjectLocationServiceGetCall), [*locations services get iam policy*](api::ProjectLocationServiceGetIamPolicyCall), [*locations services list*](api::ProjectLocationServiceListCall), [*locations services metadata imports create*](api::ProjectLocationServiceMetadataImportCreateCall), [*locations services metadata imports get*](api::ProjectLocationServiceMetadataImportGetCall), [*locations services metadata imports list*](api::ProjectLocationServiceMetadataImportListCall), [*locations services metadata imports patch*](api::ProjectLocationServiceMetadataImportPatchCall), [*locations services migration executions delete*](api::ProjectLocationServiceMigrationExecutionDeleteCall), [*locations services move table to database*](api::ProjectLocationServiceMoveTableToDatabaseCall), [*locations services patch*](api::ProjectLocationServicePatchCall), [*locations services query metadata*](api::ProjectLocationServiceQueryMetadataCall), [*locations services remove iam policy*](api::ProjectLocationServiceRemoveIamPolicyCall), [*locations services restore*](api::ProjectLocationServiceRestoreCall), [*locations services set iam policy*](api::ProjectLocationServiceSetIamPolicyCall) and [*locations services test iam permissions*](api::ProjectLocationServiceTestIamPermissionCall) @@ -67,8 +67,8 @@ //! let r = hub.projects().locations_services_restore(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -97,12 +97,12 @@ //! use std::default::Default; //! use metastore1_beta::{DataprocMetastore, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -145,10 +145,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -158,25 +158,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mirror1/src/lib.rs b/gen/mirror1/src/lib.rs index b4ac0b39e6..2b5d9de425 100644 --- a/gen/mirror1/src/lib.rs +++ b/gen/mirror1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mirror1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Mirror) ... +//! Handle the following *Resources* with ease from the central [hub](Mirror) ... //! //! * [accounts](api::Account) //! * [*insert*](api::AccountInsertCall) @@ -75,8 +75,8 @@ //! let r = hub.contacts().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -105,12 +105,12 @@ //! use std::default::Default; //! use mirror1::{Mirror, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -151,10 +151,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -164,25 +164,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/ml1/src/lib.rs b/gen/ml1/src/lib.rs index 11300025a1..89e3eac180 100644 --- a/gen/ml1/src/lib.rs +++ b/gen/ml1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/ml1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudMachineLearningEngine) ... +//! Handle the following *Resources* with ease from the central [hub](CloudMachineLearningEngine) ... //! //! * projects //! * [*explain*](api::ProjectExplainCall), [*get config*](api::ProjectGetConfigCall), [*jobs cancel*](api::ProjectJobCancelCall), [*jobs create*](api::ProjectJobCreateCall), [*jobs get*](api::ProjectJobGetCall), [*jobs get iam policy*](api::ProjectJobGetIamPolicyCall), [*jobs list*](api::ProjectJobListCall), [*jobs patch*](api::ProjectJobPatchCall), [*jobs set iam policy*](api::ProjectJobSetIamPolicyCall), [*jobs test iam permissions*](api::ProjectJobTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations studies create*](api::ProjectLocationStudyCreateCall), [*locations studies delete*](api::ProjectLocationStudyDeleteCall), [*locations studies get*](api::ProjectLocationStudyGetCall), [*locations studies list*](api::ProjectLocationStudyListCall), [*locations studies trials add measurement*](api::ProjectLocationStudyTrialAddMeasurementCall), [*locations studies trials check early stopping state*](api::ProjectLocationStudyTrialCheckEarlyStoppingStateCall), [*locations studies trials complete*](api::ProjectLocationStudyTrialCompleteCall), [*locations studies trials create*](api::ProjectLocationStudyTrialCreateCall), [*locations studies trials delete*](api::ProjectLocationStudyTrialDeleteCall), [*locations studies trials get*](api::ProjectLocationStudyTrialGetCall), [*locations studies trials list*](api::ProjectLocationStudyTrialListCall), [*locations studies trials list optimal trials*](api::ProjectLocationStudyTrialListOptimalTrialCall), [*locations studies trials stop*](api::ProjectLocationStudyTrialStopCall), [*locations studies trials suggest*](api::ProjectLocationStudyTrialSuggestCall), [*models create*](api::ProjectModelCreateCall), [*models delete*](api::ProjectModelDeleteCall), [*models get*](api::ProjectModelGetCall), [*models get iam policy*](api::ProjectModelGetIamPolicyCall), [*models list*](api::ProjectModelListCall), [*models patch*](api::ProjectModelPatchCall), [*models set iam policy*](api::ProjectModelSetIamPolicyCall), [*models test iam permissions*](api::ProjectModelTestIamPermissionCall), [*models versions create*](api::ProjectModelVersionCreateCall), [*models versions delete*](api::ProjectModelVersionDeleteCall), [*models versions get*](api::ProjectModelVersionGetCall), [*models versions list*](api::ProjectModelVersionListCall), [*models versions patch*](api::ProjectModelVersionPatchCall), [*models versions set default*](api::ProjectModelVersionSetDefaultCall), [*operations cancel*](api::ProjectOperationCancelCall), [*operations get*](api::ProjectOperationGetCall), [*operations list*](api::ProjectOperationListCall) and [*predict*](api::ProjectPredictCall) @@ -58,8 +58,8 @@ //! let r = hub.projects().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use ml1::{CloudMachineLearningEngine, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/monitoring3/src/lib.rs b/gen/monitoring3/src/lib.rs index 5a9b105c13..23a1d987fb 100644 --- a/gen/monitoring3/src/lib.rs +++ b/gen/monitoring3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/monitoring3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Monitoring) ... +//! Handle the following *Resources* with ease from the central [hub](Monitoring) ... //! //! * folders //! * [*time series list*](api::FolderTimeSeryListCall) @@ -67,8 +67,8 @@ //! let r = hub.services().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use monitoring3::{Monitoring, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -141,10 +141,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -154,25 +154,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mybusiness4/src/api.rs b/gen/mybusiness4/src/api.rs index e12d72f7e3..8837a19da0 100644 --- a/gen/mybusiness4/src/api.rs +++ b/gen/mybusiness4/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use mybusiness4::{MyBusiness, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/mybusiness4/src/lib.rs b/gen/mybusiness4/src/lib.rs index 9e7973eb96..24b3abb718 100644 --- a/gen/mybusiness4/src/lib.rs +++ b/gen/mybusiness4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mybusiness4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](MyBusiness) ... +//! Handle the following *Resources* with ease from the central [hub](MyBusiness) ... //! //! * [accounts](api::Account) //! * [*admins create*](api::AccountAdminCreateCall), [*admins delete*](api::AccountAdminDeleteCall), [*admins list*](api::AccountAdminListCall), [*admins patch*](api::AccountAdminPatchCall), [*create*](api::AccountCreateCall), [*delete notifications*](api::AccountDeleteNotificationCall), [*generate account number*](api::AccountGenerateAccountNumberCall), [*get*](api::AccountGetCall), [*get notifications*](api::AccountGetNotificationCall), [*invitations accept*](api::AccountInvitationAcceptCall), [*invitations decline*](api::AccountInvitationDeclineCall), [*invitations list*](api::AccountInvitationListCall), [*list*](api::AccountListCall), [*list recommend google locations*](api::AccountListRecommendGoogleLocationCall), [*locations admins create*](api::AccountLocationAdminCreateCall), [*locations admins delete*](api::AccountLocationAdminDeleteCall), [*locations admins list*](api::AccountLocationAdminListCall), [*locations admins patch*](api::AccountLocationAdminPatchCall), [*locations associate*](api::AccountLocationAssociateCall), [*locations batch get*](api::AccountLocationBatchGetCall), [*locations batch get reviews*](api::AccountLocationBatchGetReviewCall), [*locations clear association*](api::AccountLocationClearAssociationCall), [*locations create*](api::AccountLocationCreateCall), [*locations delete*](api::AccountLocationDeleteCall), [*locations fetch verification options*](api::AccountLocationFetchVerificationOptionCall), [*locations find matches*](api::AccountLocationFindMatchCall), [*locations followers get metadata*](api::AccountLocationFollowerGetMetadataCall), [*locations get*](api::AccountLocationGetCall), [*locations get google updated*](api::AccountLocationGetGoogleUpdatedCall), [*locations list*](api::AccountLocationListCall), [*locations local posts create*](api::AccountLocationLocalPostCreateCall), [*locations local posts delete*](api::AccountLocationLocalPostDeleteCall), [*locations local posts get*](api::AccountLocationLocalPostGetCall), [*locations local posts list*](api::AccountLocationLocalPostListCall), [*locations local posts patch*](api::AccountLocationLocalPostPatchCall), [*locations local posts report insights*](api::AccountLocationLocalPostReportInsightCall), [*locations media create*](api::AccountLocationMediaCreateCall), [*locations media customers get*](api::AccountLocationMediaCustomerGetCall), [*locations media customers list*](api::AccountLocationMediaCustomerListCall), [*locations media delete*](api::AccountLocationMediaDeleteCall), [*locations media get*](api::AccountLocationMediaGetCall), [*locations media list*](api::AccountLocationMediaListCall), [*locations media patch*](api::AccountLocationMediaPatchCall), [*locations media start upload*](api::AccountLocationMediaStartUploadCall), [*locations patch*](api::AccountLocationPatchCall), [*locations questions answers delete*](api::AccountLocationQuestionAnswerDeleteCall), [*locations questions answers list*](api::AccountLocationQuestionAnswerListCall), [*locations questions answers upsert*](api::AccountLocationQuestionAnswerUpsertCall), [*locations questions create*](api::AccountLocationQuestionCreateCall), [*locations questions delete*](api::AccountLocationQuestionDeleteCall), [*locations questions list*](api::AccountLocationQuestionListCall), [*locations questions patch*](api::AccountLocationQuestionPatchCall), [*locations report insights*](api::AccountLocationReportInsightCall), [*locations reviews delete reply*](api::AccountLocationReviewDeleteReplyCall), [*locations reviews get*](api::AccountLocationReviewGetCall), [*locations reviews list*](api::AccountLocationReviewListCall), [*locations reviews update reply*](api::AccountLocationReviewUpdateReplyCall), [*locations transfer*](api::AccountLocationTransferCall), [*locations verifications complete*](api::AccountLocationVerificationCompleteCall), [*locations verifications list*](api::AccountLocationVerificationListCall), [*locations verify*](api::AccountLocationVerifyCall), [*update*](api::AccountUpdateCall) and [*update notifications*](api::AccountUpdateNotificationCall) @@ -122,8 +122,8 @@ //! let r = hub.accounts().update_notifications(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -151,12 +151,12 @@ //! use std::default::Default; //! use mybusiness4::{MyBusiness, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -197,10 +197,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -210,25 +210,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mybusinessaccountmanagement1/src/api.rs b/gen/mybusinessaccountmanagement1/src/api.rs index c890a0ca66..f789916ad1 100644 --- a/gen/mybusinessaccountmanagement1/src/api.rs +++ b/gen/mybusinessaccountmanagement1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use mybusinessaccountmanagement1::{MyBusinessAccountManagement, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/mybusinessaccountmanagement1/src/lib.rs b/gen/mybusinessaccountmanagement1/src/lib.rs index a4bb5c7b72..9a95288a71 100644 --- a/gen/mybusinessaccountmanagement1/src/lib.rs +++ b/gen/mybusinessaccountmanagement1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mybusinessaccountmanagement1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](MyBusinessAccountManagement) ... +//! Handle the following *Resources* with ease from the central [hub](MyBusinessAccountManagement) ... //! //! * [accounts](api::Account) //! * [*admins create*](api::AccountAdminCreateCall), [*admins delete*](api::AccountAdminDeleteCall), [*admins list*](api::AccountAdminListCall), [*admins patch*](api::AccountAdminPatchCall), [*create*](api::AccountCreateCall), [*get*](api::AccountGetCall), [*invitations accept*](api::AccountInvitationAcceptCall), [*invitations decline*](api::AccountInvitationDeclineCall), [*invitations list*](api::AccountInvitationListCall), [*list*](api::AccountListCall) and [*patch*](api::AccountPatchCall) @@ -62,8 +62,8 @@ //! let r = hub.accounts().patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use mybusinessaccountmanagement1::{MyBusinessAccountManagement, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mybusinessbusinesscalls1/src/api.rs b/gen/mybusinessbusinesscalls1/src/api.rs index 539d51f8a4..6e4ceddbcb 100644 --- a/gen/mybusinessbusinesscalls1/src/api.rs +++ b/gen/mybusinessbusinesscalls1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use mybusinessbusinesscalls1::{MyBusinessBusinessCalls, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/mybusinessbusinesscalls1/src/lib.rs b/gen/mybusinessbusinesscalls1/src/lib.rs index d71d68bc18..c277f5cb33 100644 --- a/gen/mybusinessbusinesscalls1/src/lib.rs +++ b/gen/mybusinessbusinesscalls1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mybusinessbusinesscalls1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](MyBusinessBusinessCalls) ... +//! Handle the following *Resources* with ease from the central [hub](MyBusinessBusinessCalls) ... //! //! * locations //! * [*businesscallsinsights list*](api::LocationBusinesscallsinsightListCall), [*get businesscallssettings*](api::LocationGetBusinesscallssettingCall) and [*update businesscallssettings*](api::LocationUpdateBusinesscallssettingCall) @@ -51,8 +51,8 @@ //! let r = hub.locations().update_businesscallssettings(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use mybusinessbusinesscalls1::{MyBusinessBusinessCalls, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mybusinessbusinessinformation1/src/api.rs b/gen/mybusinessbusinessinformation1/src/api.rs index 7133046526..96177511b7 100644 --- a/gen/mybusinessbusinessinformation1/src/api.rs +++ b/gen/mybusinessbusinessinformation1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use mybusinessbusinessinformation1::{MyBusinessBusinessInformation, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/mybusinessbusinessinformation1/src/lib.rs b/gen/mybusinessbusinessinformation1/src/lib.rs index 6816b56063..d81197b4b0 100644 --- a/gen/mybusinessbusinessinformation1/src/lib.rs +++ b/gen/mybusinessbusinessinformation1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mybusinessbusinessinformation1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](MyBusinessBusinessInformation) ... +//! Handle the following *Resources* with ease from the central [hub](MyBusinessBusinessInformation) ... //! //! * accounts //! * [*locations create*](api::AccountLocationCreateCall) and [*locations list*](api::AccountLocationListCall) @@ -67,8 +67,8 @@ //! let r = hub.locations().update_attributes(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -97,12 +97,12 @@ //! use std::default::Default; //! use mybusinessbusinessinformation1::{MyBusinessBusinessInformation, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -145,10 +145,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -158,25 +158,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mybusinesslodging1/src/api.rs b/gen/mybusinesslodging1/src/api.rs index 10a903ceff..978cd33c15 100644 --- a/gen/mybusinesslodging1/src/api.rs +++ b/gen/mybusinesslodging1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use mybusinesslodging1::{MyBusinessLodging, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/mybusinesslodging1/src/lib.rs b/gen/mybusinesslodging1/src/lib.rs index a7aed5de10..363d4410d9 100644 --- a/gen/mybusinesslodging1/src/lib.rs +++ b/gen/mybusinesslodging1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mybusinesslodging1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](MyBusinessLodging) ... +//! Handle the following *Resources* with ease from the central [hub](MyBusinessLodging) ... //! //! * locations //! * [*get lodging*](api::LocationGetLodgingCall), [*lodging get google updated*](api::LocationLodgingGetGoogleUpdatedCall) and [*update lodging*](api::LocationUpdateLodgingCall) @@ -51,8 +51,8 @@ //! let r = hub.locations().update_lodging(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use mybusinesslodging1::{MyBusinessLodging, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mybusinessnotifications1/src/api.rs b/gen/mybusinessnotifications1/src/api.rs index e33a439a5d..ff1488150e 100644 --- a/gen/mybusinessnotifications1/src/api.rs +++ b/gen/mybusinessnotifications1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use mybusinessnotifications1::{MyBusinessNotificationSettings, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/mybusinessnotifications1/src/lib.rs b/gen/mybusinessnotifications1/src/lib.rs index 672d8ac4ac..9cd93b7eda 100644 --- a/gen/mybusinessnotifications1/src/lib.rs +++ b/gen/mybusinessnotifications1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mybusinessnotifications1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](MyBusinessNotificationSettings) ... +//! Handle the following *Resources* with ease from the central [hub](MyBusinessNotificationSettings) ... //! //! * accounts //! * [*get notification setting*](api::AccountGetNotificationSettingCall) and [*update notification setting*](api::AccountUpdateNotificationSettingCall) @@ -51,8 +51,8 @@ //! let r = hub.accounts().update_notification_setting(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use mybusinessnotifications1::{MyBusinessNotificationSettings, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mybusinessplaceactions1/src/api.rs b/gen/mybusinessplaceactions1/src/api.rs index fa0b3bcdd9..4dd9105127 100644 --- a/gen/mybusinessplaceactions1/src/api.rs +++ b/gen/mybusinessplaceactions1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use mybusinessplaceactions1::{MyBusinessPlaceActions, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/mybusinessplaceactions1/src/lib.rs b/gen/mybusinessplaceactions1/src/lib.rs index 4dcdb5b9b3..387eed2122 100644 --- a/gen/mybusinessplaceactions1/src/lib.rs +++ b/gen/mybusinessplaceactions1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mybusinessplaceactions1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](MyBusinessPlaceActions) ... +//! Handle the following *Resources* with ease from the central [hub](MyBusinessPlaceActions) ... //! //! * locations //! * [*place action links create*](api::LocationPlaceActionLinkCreateCall), [*place action links delete*](api::LocationPlaceActionLinkDeleteCall), [*place action links get*](api::LocationPlaceActionLinkGetCall), [*place action links list*](api::LocationPlaceActionLinkListCall) and [*place action links patch*](api::LocationPlaceActionLinkPatchCall) @@ -54,8 +54,8 @@ //! let r = hub.locations().place_action_links_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use mybusinessplaceactions1::{MyBusinessPlaceActions, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/mybusinessverifications1/src/api.rs b/gen/mybusinessverifications1/src/api.rs index b0161b9980..31a2a960a6 100644 --- a/gen/mybusinessverifications1/src/api.rs +++ b/gen/mybusinessverifications1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use mybusinessverifications1::{MyBusinessVerifications, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/mybusinessverifications1/src/lib.rs b/gen/mybusinessverifications1/src/lib.rs index 1b1734e283..f53d503ea6 100644 --- a/gen/mybusinessverifications1/src/lib.rs +++ b/gen/mybusinessverifications1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/mybusinessverifications1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](MyBusinessVerifications) ... +//! Handle the following *Resources* with ease from the central [hub](MyBusinessVerifications) ... //! //! * locations //! * [*fetch verification options*](api::LocationFetchVerificationOptionCall), [*get voice of merchant state*](api::LocationGetVoiceOfMerchantStateCall), [*verifications complete*](api::LocationVerificationCompleteCall), [*verifications list*](api::LocationVerificationListCall) and [*verify*](api::LocationVerifyCall) @@ -50,8 +50,8 @@ //! let r = hub.locations().verify(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use mybusinessverifications1::{MyBusinessVerifications, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/networkconnectivity1/src/lib.rs b/gen/networkconnectivity1/src/lib.rs index feed7fd451..662ad584ae 100644 --- a/gen/networkconnectivity1/src/lib.rs +++ b/gen/networkconnectivity1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/networkconnectivity1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Networkconnectivity) ... +//! Handle the following *Resources* with ease from the central [hub](Networkconnectivity) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations global hubs accept spoke*](api::ProjectLocationGlobalHubAcceptSpokeCall), [*locations global hubs create*](api::ProjectLocationGlobalHubCreateCall), [*locations global hubs delete*](api::ProjectLocationGlobalHubDeleteCall), [*locations global hubs get*](api::ProjectLocationGlobalHubGetCall), [*locations global hubs get iam policy*](api::ProjectLocationGlobalHubGetIamPolicyCall), [*locations global hubs groups get*](api::ProjectLocationGlobalHubGroupGetCall), [*locations global hubs groups get iam policy*](api::ProjectLocationGlobalHubGroupGetIamPolicyCall), [*locations global hubs groups list*](api::ProjectLocationGlobalHubGroupListCall), [*locations global hubs groups set iam policy*](api::ProjectLocationGlobalHubGroupSetIamPolicyCall), [*locations global hubs groups test iam permissions*](api::ProjectLocationGlobalHubGroupTestIamPermissionCall), [*locations global hubs list*](api::ProjectLocationGlobalHubListCall), [*locations global hubs list spokes*](api::ProjectLocationGlobalHubListSpokeCall), [*locations global hubs patch*](api::ProjectLocationGlobalHubPatchCall), [*locations global hubs reject spoke*](api::ProjectLocationGlobalHubRejectSpokeCall), [*locations global hubs route tables get*](api::ProjectLocationGlobalHubRouteTableGetCall), [*locations global hubs route tables list*](api::ProjectLocationGlobalHubRouteTableListCall), [*locations global hubs route tables routes get*](api::ProjectLocationGlobalHubRouteTableRouteGetCall), [*locations global hubs route tables routes list*](api::ProjectLocationGlobalHubRouteTableRouteListCall), [*locations global hubs set iam policy*](api::ProjectLocationGlobalHubSetIamPolicyCall), [*locations global hubs test iam permissions*](api::ProjectLocationGlobalHubTestIamPermissionCall), [*locations global policy based routes create*](api::ProjectLocationGlobalPolicyBasedRouteCreateCall), [*locations global policy based routes delete*](api::ProjectLocationGlobalPolicyBasedRouteDeleteCall), [*locations global policy based routes get*](api::ProjectLocationGlobalPolicyBasedRouteGetCall), [*locations global policy based routes get iam policy*](api::ProjectLocationGlobalPolicyBasedRouteGetIamPolicyCall), [*locations global policy based routes list*](api::ProjectLocationGlobalPolicyBasedRouteListCall), [*locations global policy based routes set iam policy*](api::ProjectLocationGlobalPolicyBasedRouteSetIamPolicyCall), [*locations global policy based routes test iam permissions*](api::ProjectLocationGlobalPolicyBasedRouteTestIamPermissionCall), [*locations internal ranges create*](api::ProjectLocationInternalRangeCreateCall), [*locations internal ranges delete*](api::ProjectLocationInternalRangeDeleteCall), [*locations internal ranges get*](api::ProjectLocationInternalRangeGetCall), [*locations internal ranges list*](api::ProjectLocationInternalRangeListCall), [*locations internal ranges patch*](api::ProjectLocationInternalRangePatchCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations service classes delete*](api::ProjectLocationServiceClassDeleteCall), [*locations service classes get*](api::ProjectLocationServiceClassGetCall), [*locations service classes get iam policy*](api::ProjectLocationServiceClassGetIamPolicyCall), [*locations service classes list*](api::ProjectLocationServiceClassListCall), [*locations service classes patch*](api::ProjectLocationServiceClassPatchCall), [*locations service classes set iam policy*](api::ProjectLocationServiceClassSetIamPolicyCall), [*locations service classes test iam permissions*](api::ProjectLocationServiceClassTestIamPermissionCall), [*locations service connection maps create*](api::ProjectLocationServiceConnectionMapCreateCall), [*locations service connection maps delete*](api::ProjectLocationServiceConnectionMapDeleteCall), [*locations service connection maps get*](api::ProjectLocationServiceConnectionMapGetCall), [*locations service connection maps get iam policy*](api::ProjectLocationServiceConnectionMapGetIamPolicyCall), [*locations service connection maps list*](api::ProjectLocationServiceConnectionMapListCall), [*locations service connection maps patch*](api::ProjectLocationServiceConnectionMapPatchCall), [*locations service connection maps set iam policy*](api::ProjectLocationServiceConnectionMapSetIamPolicyCall), [*locations service connection maps test iam permissions*](api::ProjectLocationServiceConnectionMapTestIamPermissionCall), [*locations service connection policies create*](api::ProjectLocationServiceConnectionPolicyCreateCall), [*locations service connection policies delete*](api::ProjectLocationServiceConnectionPolicyDeleteCall), [*locations service connection policies get*](api::ProjectLocationServiceConnectionPolicyGetCall), [*locations service connection policies get iam policy*](api::ProjectLocationServiceConnectionPolicyGetIamPolicyCall), [*locations service connection policies list*](api::ProjectLocationServiceConnectionPolicyListCall), [*locations service connection policies patch*](api::ProjectLocationServiceConnectionPolicyPatchCall), [*locations service connection policies set iam policy*](api::ProjectLocationServiceConnectionPolicySetIamPolicyCall), [*locations service connection policies test iam permissions*](api::ProjectLocationServiceConnectionPolicyTestIamPermissionCall), [*locations service connection tokens create*](api::ProjectLocationServiceConnectionTokenCreateCall), [*locations service connection tokens delete*](api::ProjectLocationServiceConnectionTokenDeleteCall), [*locations service connection tokens get*](api::ProjectLocationServiceConnectionTokenGetCall), [*locations service connection tokens list*](api::ProjectLocationServiceConnectionTokenListCall), [*locations spokes create*](api::ProjectLocationSpokeCreateCall), [*locations spokes delete*](api::ProjectLocationSpokeDeleteCall), [*locations spokes get*](api::ProjectLocationSpokeGetCall), [*locations spokes get iam policy*](api::ProjectLocationSpokeGetIamPolicyCall), [*locations spokes list*](api::ProjectLocationSpokeListCall), [*locations spokes patch*](api::ProjectLocationSpokePatchCall), [*locations spokes set iam policy*](api::ProjectLocationSpokeSetIamPolicyCall) and [*locations spokes test iam permissions*](api::ProjectLocationSpokeTestIamPermissionCall) @@ -73,8 +73,8 @@ //! let r = hub.projects().locations_spokes_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -103,12 +103,12 @@ //! use std::default::Default; //! use networkconnectivity1::{Networkconnectivity, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -151,10 +151,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -164,25 +164,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/networkconnectivity1_alpha1/src/lib.rs b/gen/networkconnectivity1_alpha1/src/lib.rs index 4822a490c4..4bde7c1c59 100644 --- a/gen/networkconnectivity1_alpha1/src/lib.rs +++ b/gen/networkconnectivity1_alpha1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/networkconnectivity1_alpha1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Networkconnectivity) ... +//! Handle the following *Resources* with ease from the central [hub](Networkconnectivity) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations global hubs create*](api::ProjectLocationGlobalHubCreateCall), [*locations global hubs delete*](api::ProjectLocationGlobalHubDeleteCall), [*locations global hubs get*](api::ProjectLocationGlobalHubGetCall), [*locations global hubs get iam policy*](api::ProjectLocationGlobalHubGetIamPolicyCall), [*locations global hubs list*](api::ProjectLocationGlobalHubListCall), [*locations global hubs patch*](api::ProjectLocationGlobalHubPatchCall), [*locations global hubs set iam policy*](api::ProjectLocationGlobalHubSetIamPolicyCall), [*locations global hubs test iam permissions*](api::ProjectLocationGlobalHubTestIamPermissionCall), [*locations internal ranges create*](api::ProjectLocationInternalRangeCreateCall), [*locations internal ranges delete*](api::ProjectLocationInternalRangeDeleteCall), [*locations internal ranges get*](api::ProjectLocationInternalRangeGetCall), [*locations internal ranges get iam policy*](api::ProjectLocationInternalRangeGetIamPolicyCall), [*locations internal ranges list*](api::ProjectLocationInternalRangeListCall), [*locations internal ranges patch*](api::ProjectLocationInternalRangePatchCall), [*locations internal ranges set iam policy*](api::ProjectLocationInternalRangeSetIamPolicyCall), [*locations internal ranges test iam permissions*](api::ProjectLocationInternalRangeTestIamPermissionCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations spokes create*](api::ProjectLocationSpokeCreateCall), [*locations spokes delete*](api::ProjectLocationSpokeDeleteCall), [*locations spokes get*](api::ProjectLocationSpokeGetCall), [*locations spokes get iam policy*](api::ProjectLocationSpokeGetIamPolicyCall), [*locations spokes list*](api::ProjectLocationSpokeListCall), [*locations spokes patch*](api::ProjectLocationSpokePatchCall), [*locations spokes set iam policy*](api::ProjectLocationSpokeSetIamPolicyCall) and [*locations spokes test iam permissions*](api::ProjectLocationSpokeTestIamPermissionCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().locations_spokes_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use networkconnectivity1_alpha1::{Networkconnectivity, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -137,10 +137,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -150,25 +150,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/networkmanagement1/src/lib.rs b/gen/networkmanagement1/src/lib.rs index 193c55ffd1..edc2734e74 100644 --- a/gen/networkmanagement1/src/lib.rs +++ b/gen/networkmanagement1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/networkmanagement1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](NetworkManagement) ... +//! Handle the following *Resources* with ease from the central [hub](NetworkManagement) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations global connectivity tests create*](api::ProjectLocationGlobalConnectivityTestCreateCall), [*locations global connectivity tests delete*](api::ProjectLocationGlobalConnectivityTestDeleteCall), [*locations global connectivity tests get*](api::ProjectLocationGlobalConnectivityTestGetCall), [*locations global connectivity tests get iam policy*](api::ProjectLocationGlobalConnectivityTestGetIamPolicyCall), [*locations global connectivity tests list*](api::ProjectLocationGlobalConnectivityTestListCall), [*locations global connectivity tests patch*](api::ProjectLocationGlobalConnectivityTestPatchCall), [*locations global connectivity tests rerun*](api::ProjectLocationGlobalConnectivityTestRerunCall), [*locations global connectivity tests set iam policy*](api::ProjectLocationGlobalConnectivityTestSetIamPolicyCall), [*locations global connectivity tests test iam permissions*](api::ProjectLocationGlobalConnectivityTestTestIamPermissionCall), [*locations global operations cancel*](api::ProjectLocationGlobalOperationCancelCall), [*locations global operations delete*](api::ProjectLocationGlobalOperationDeleteCall), [*locations global operations get*](api::ProjectLocationGlobalOperationGetCall), [*locations global operations list*](api::ProjectLocationGlobalOperationListCall) and [*locations list*](api::ProjectLocationListCall) @@ -54,8 +54,8 @@ //! let r = hub.projects().locations_global_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use networkmanagement1::{NetworkManagement, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/networksecurity1/src/lib.rs b/gen/networksecurity1/src/lib.rs index 1fe31f2d26..25b2ebf414 100644 --- a/gen/networksecurity1/src/lib.rs +++ b/gen/networksecurity1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/networksecurity1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](NetworkSecurity) ... +//! Handle the following *Resources* with ease from the central [hub](NetworkSecurity) ... //! //! * organizations //! * [*locations address groups add items*](api::OrganizationLocationAddressGroupAddItemCall), [*locations address groups clone items*](api::OrganizationLocationAddressGroupCloneItemCall), [*locations address groups create*](api::OrganizationLocationAddressGroupCreateCall), [*locations address groups delete*](api::OrganizationLocationAddressGroupDeleteCall), [*locations address groups get*](api::OrganizationLocationAddressGroupGetCall), [*locations address groups list*](api::OrganizationLocationAddressGroupListCall), [*locations address groups list references*](api::OrganizationLocationAddressGroupListReferenceCall), [*locations address groups patch*](api::OrganizationLocationAddressGroupPatchCall), [*locations address groups remove items*](api::OrganizationLocationAddressGroupRemoveItemCall), [*locations operations cancel*](api::OrganizationLocationOperationCancelCall), [*locations operations delete*](api::OrganizationLocationOperationDeleteCall), [*locations operations get*](api::OrganizationLocationOperationGetCall) and [*locations operations list*](api::OrganizationLocationOperationListCall) @@ -86,8 +86,8 @@ //! let r = hub.projects().locations_url_lists_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -116,12 +116,12 @@ //! use std::default::Default; //! use networksecurity1::{NetworkSecurity, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -164,10 +164,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -177,25 +177,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/networkservices1/src/lib.rs b/gen/networkservices1/src/lib.rs index da0c9ee9c1..1158a11fbc 100644 --- a/gen/networkservices1/src/lib.rs +++ b/gen/networkservices1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/networkservices1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](NetworkServices) ... +//! Handle the following *Resources* with ease from the central [hub](NetworkServices) ... //! //! * projects //! * [*locations edge cache keysets get iam policy*](api::ProjectLocationEdgeCacheKeysetGetIamPolicyCall), [*locations edge cache keysets set iam policy*](api::ProjectLocationEdgeCacheKeysetSetIamPolicyCall), [*locations edge cache keysets test iam permissions*](api::ProjectLocationEdgeCacheKeysetTestIamPermissionCall), [*locations edge cache origins get iam policy*](api::ProjectLocationEdgeCacheOriginGetIamPolicyCall), [*locations edge cache origins set iam policy*](api::ProjectLocationEdgeCacheOriginSetIamPolicyCall), [*locations edge cache origins test iam permissions*](api::ProjectLocationEdgeCacheOriginTestIamPermissionCall), [*locations edge cache services get iam policy*](api::ProjectLocationEdgeCacheServiceGetIamPolicyCall), [*locations edge cache services set iam policy*](api::ProjectLocationEdgeCacheServiceSetIamPolicyCall), [*locations edge cache services test iam permissions*](api::ProjectLocationEdgeCacheServiceTestIamPermissionCall), [*locations endpoint policies create*](api::ProjectLocationEndpointPolicyCreateCall), [*locations endpoint policies delete*](api::ProjectLocationEndpointPolicyDeleteCall), [*locations endpoint policies get*](api::ProjectLocationEndpointPolicyGetCall), [*locations endpoint policies get iam policy*](api::ProjectLocationEndpointPolicyGetIamPolicyCall), [*locations endpoint policies list*](api::ProjectLocationEndpointPolicyListCall), [*locations endpoint policies patch*](api::ProjectLocationEndpointPolicyPatchCall), [*locations endpoint policies set iam policy*](api::ProjectLocationEndpointPolicySetIamPolicyCall), [*locations endpoint policies test iam permissions*](api::ProjectLocationEndpointPolicyTestIamPermissionCall), [*locations gateways create*](api::ProjectLocationGatewayCreateCall), [*locations gateways delete*](api::ProjectLocationGatewayDeleteCall), [*locations gateways get*](api::ProjectLocationGatewayGetCall), [*locations gateways get iam policy*](api::ProjectLocationGatewayGetIamPolicyCall), [*locations gateways list*](api::ProjectLocationGatewayListCall), [*locations gateways patch*](api::ProjectLocationGatewayPatchCall), [*locations gateways set iam policy*](api::ProjectLocationGatewaySetIamPolicyCall), [*locations gateways test iam permissions*](api::ProjectLocationGatewayTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations grpc routes create*](api::ProjectLocationGrpcRouteCreateCall), [*locations grpc routes delete*](api::ProjectLocationGrpcRouteDeleteCall), [*locations grpc routes get*](api::ProjectLocationGrpcRouteGetCall), [*locations grpc routes list*](api::ProjectLocationGrpcRouteListCall), [*locations grpc routes patch*](api::ProjectLocationGrpcRoutePatchCall), [*locations http routes create*](api::ProjectLocationHttpRouteCreateCall), [*locations http routes delete*](api::ProjectLocationHttpRouteDeleteCall), [*locations http routes get*](api::ProjectLocationHttpRouteGetCall), [*locations http routes list*](api::ProjectLocationHttpRouteListCall), [*locations http routes patch*](api::ProjectLocationHttpRoutePatchCall), [*locations lb route extensions create*](api::ProjectLocationLbRouteExtensionCreateCall), [*locations lb route extensions delete*](api::ProjectLocationLbRouteExtensionDeleteCall), [*locations lb route extensions get*](api::ProjectLocationLbRouteExtensionGetCall), [*locations lb route extensions list*](api::ProjectLocationLbRouteExtensionListCall), [*locations lb route extensions patch*](api::ProjectLocationLbRouteExtensionPatchCall), [*locations lb traffic extensions create*](api::ProjectLocationLbTrafficExtensionCreateCall), [*locations lb traffic extensions delete*](api::ProjectLocationLbTrafficExtensionDeleteCall), [*locations lb traffic extensions get*](api::ProjectLocationLbTrafficExtensionGetCall), [*locations lb traffic extensions list*](api::ProjectLocationLbTrafficExtensionListCall), [*locations lb traffic extensions patch*](api::ProjectLocationLbTrafficExtensionPatchCall), [*locations list*](api::ProjectLocationListCall), [*locations meshes create*](api::ProjectLocationMeshCreateCall), [*locations meshes delete*](api::ProjectLocationMeshDeleteCall), [*locations meshes get*](api::ProjectLocationMeshGetCall), [*locations meshes get iam policy*](api::ProjectLocationMeshGetIamPolicyCall), [*locations meshes list*](api::ProjectLocationMeshListCall), [*locations meshes patch*](api::ProjectLocationMeshPatchCall), [*locations meshes set iam policy*](api::ProjectLocationMeshSetIamPolicyCall), [*locations meshes test iam permissions*](api::ProjectLocationMeshTestIamPermissionCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations service bindings create*](api::ProjectLocationServiceBindingCreateCall), [*locations service bindings delete*](api::ProjectLocationServiceBindingDeleteCall), [*locations service bindings get*](api::ProjectLocationServiceBindingGetCall), [*locations service bindings get iam policy*](api::ProjectLocationServiceBindingGetIamPolicyCall), [*locations service bindings list*](api::ProjectLocationServiceBindingListCall), [*locations service bindings set iam policy*](api::ProjectLocationServiceBindingSetIamPolicyCall), [*locations service bindings test iam permissions*](api::ProjectLocationServiceBindingTestIamPermissionCall), [*locations service lb policies create*](api::ProjectLocationServiceLbPolicyCreateCall), [*locations service lb policies delete*](api::ProjectLocationServiceLbPolicyDeleteCall), [*locations service lb policies get*](api::ProjectLocationServiceLbPolicyGetCall), [*locations service lb policies get iam policy*](api::ProjectLocationServiceLbPolicyGetIamPolicyCall), [*locations service lb policies list*](api::ProjectLocationServiceLbPolicyListCall), [*locations service lb policies patch*](api::ProjectLocationServiceLbPolicyPatchCall), [*locations service lb policies set iam policy*](api::ProjectLocationServiceLbPolicySetIamPolicyCall), [*locations service lb policies test iam permissions*](api::ProjectLocationServiceLbPolicyTestIamPermissionCall), [*locations tcp routes create*](api::ProjectLocationTcpRouteCreateCall), [*locations tcp routes delete*](api::ProjectLocationTcpRouteDeleteCall), [*locations tcp routes get*](api::ProjectLocationTcpRouteGetCall), [*locations tcp routes list*](api::ProjectLocationTcpRouteListCall), [*locations tcp routes patch*](api::ProjectLocationTcpRoutePatchCall), [*locations tls routes create*](api::ProjectLocationTlsRouteCreateCall), [*locations tls routes delete*](api::ProjectLocationTlsRouteDeleteCall), [*locations tls routes get*](api::ProjectLocationTlsRouteGetCall), [*locations tls routes list*](api::ProjectLocationTlsRouteListCall) and [*locations tls routes patch*](api::ProjectLocationTlsRoutePatchCall) @@ -82,8 +82,8 @@ //! let r = hub.projects().locations_tls_routes_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -112,12 +112,12 @@ //! use std::default::Default; //! use networkservices1::{NetworkServices, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -160,10 +160,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -173,25 +173,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/notebooks1/src/lib.rs b/gen/notebooks1/src/lib.rs index f34756d0a0..4d56eee9c2 100644 --- a/gen/notebooks1/src/lib.rs +++ b/gen/notebooks1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/notebooks1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](AIPlatformNotebooks) ... +//! Handle the following *Resources* with ease from the central [hub](AIPlatformNotebooks) ... //! //! * projects //! * [*locations environments create*](api::ProjectLocationEnvironmentCreateCall), [*locations environments delete*](api::ProjectLocationEnvironmentDeleteCall), [*locations environments get*](api::ProjectLocationEnvironmentGetCall), [*locations environments list*](api::ProjectLocationEnvironmentListCall), [*locations executions create*](api::ProjectLocationExecutionCreateCall), [*locations executions delete*](api::ProjectLocationExecutionDeleteCall), [*locations executions get*](api::ProjectLocationExecutionGetCall), [*locations executions list*](api::ProjectLocationExecutionListCall), [*locations get*](api::ProjectLocationGetCall), [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances diagnose*](api::ProjectLocationInstanceDiagnoseCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances get iam policy*](api::ProjectLocationInstanceGetIamPolicyCall), [*locations instances get instance health*](api::ProjectLocationInstanceGetInstanceHealthCall), [*locations instances is upgradeable*](api::ProjectLocationInstanceIsUpgradeableCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances migrate*](api::ProjectLocationInstanceMigrateCall), [*locations instances register*](api::ProjectLocationInstanceRegisterCall), [*locations instances report*](api::ProjectLocationInstanceReportCall), [*locations instances report event*](api::ProjectLocationInstanceReportEventCall), [*locations instances reset*](api::ProjectLocationInstanceResetCall), [*locations instances rollback*](api::ProjectLocationInstanceRollbackCall), [*locations instances set accelerator*](api::ProjectLocationInstanceSetAcceleratorCall), [*locations instances set iam policy*](api::ProjectLocationInstanceSetIamPolicyCall), [*locations instances set labels*](api::ProjectLocationInstanceSetLabelCall), [*locations instances set machine type*](api::ProjectLocationInstanceSetMachineTypeCall), [*locations instances start*](api::ProjectLocationInstanceStartCall), [*locations instances stop*](api::ProjectLocationInstanceStopCall), [*locations instances test iam permissions*](api::ProjectLocationInstanceTestIamPermissionCall), [*locations instances update config*](api::ProjectLocationInstanceUpdateConfigCall), [*locations instances update metadata items*](api::ProjectLocationInstanceUpdateMetadataItemCall), [*locations instances update shielded instance config*](api::ProjectLocationInstanceUpdateShieldedInstanceConfigCall), [*locations instances upgrade*](api::ProjectLocationInstanceUpgradeCall), [*locations instances upgrade internal*](api::ProjectLocationInstanceUpgradeInternalCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations runtimes create*](api::ProjectLocationRuntimeCreateCall), [*locations runtimes delete*](api::ProjectLocationRuntimeDeleteCall), [*locations runtimes diagnose*](api::ProjectLocationRuntimeDiagnoseCall), [*locations runtimes get*](api::ProjectLocationRuntimeGetCall), [*locations runtimes get iam policy*](api::ProjectLocationRuntimeGetIamPolicyCall), [*locations runtimes list*](api::ProjectLocationRuntimeListCall), [*locations runtimes migrate*](api::ProjectLocationRuntimeMigrateCall), [*locations runtimes patch*](api::ProjectLocationRuntimePatchCall), [*locations runtimes refresh runtime token internal*](api::ProjectLocationRuntimeRefreshRuntimeTokenInternalCall), [*locations runtimes report event*](api::ProjectLocationRuntimeReportEventCall), [*locations runtimes reset*](api::ProjectLocationRuntimeResetCall), [*locations runtimes set iam policy*](api::ProjectLocationRuntimeSetIamPolicyCall), [*locations runtimes start*](api::ProjectLocationRuntimeStartCall), [*locations runtimes stop*](api::ProjectLocationRuntimeStopCall), [*locations runtimes switch*](api::ProjectLocationRuntimeSwitchCall), [*locations runtimes test iam permissions*](api::ProjectLocationRuntimeTestIamPermissionCall), [*locations runtimes upgrade*](api::ProjectLocationRuntimeUpgradeCall), [*locations schedules create*](api::ProjectLocationScheduleCreateCall), [*locations schedules delete*](api::ProjectLocationScheduleDeleteCall), [*locations schedules get*](api::ProjectLocationScheduleGetCall), [*locations schedules list*](api::ProjectLocationScheduleListCall) and [*locations schedules trigger*](api::ProjectLocationScheduleTriggerCall) @@ -86,8 +86,8 @@ //! let r = hub.projects().locations_schedules_trigger(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -116,12 +116,12 @@ //! use std::default::Default; //! use notebooks1::{AIPlatformNotebooks, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -164,10 +164,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -177,25 +177,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/ondemandscanning1/src/lib.rs b/gen/ondemandscanning1/src/lib.rs index 5aa085e5d7..53a3688e04 100644 --- a/gen/ondemandscanning1/src/lib.rs +++ b/gen/ondemandscanning1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/ondemandscanning1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](OnDemandScanning) ... +//! Handle the following *Resources* with ease from the central [hub](OnDemandScanning) ... //! //! * projects //! * [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations operations wait*](api::ProjectLocationOperationWaitCall), [*locations scans analyze packages*](api::ProjectLocationScanAnalyzePackageCall) and [*locations scans vulnerabilities list*](api::ProjectLocationScanVulnerabilityListCall) @@ -52,8 +52,8 @@ //! let r = hub.projects().locations_scans_analyze_packages(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use ondemandscanning1::{OnDemandScanning, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -123,10 +123,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -136,25 +136,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/orgpolicy2/src/lib.rs b/gen/orgpolicy2/src/lib.rs index a988610961..b1568f8940 100644 --- a/gen/orgpolicy2/src/lib.rs +++ b/gen/orgpolicy2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/orgpolicy2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](OrgPolicyAPI) ... +//! Handle the following *Resources* with ease from the central [hub](OrgPolicyAPI) ... //! //! * folders //! * [*constraints list*](api::FolderConstraintListCall), [*policies create*](api::FolderPolicyCreateCall), [*policies delete*](api::FolderPolicyDeleteCall), [*policies get*](api::FolderPolicyGetCall), [*policies get effective policy*](api::FolderPolicyGetEffectivePolicyCall), [*policies list*](api::FolderPolicyListCall) and [*policies patch*](api::FolderPolicyPatchCall) @@ -65,8 +65,8 @@ //! let r = hub.projects().policies_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -95,12 +95,12 @@ //! use std::default::Default; //! use orgpolicy2::{OrgPolicyAPI, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -142,10 +142,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -155,25 +155,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/oslogin1/src/lib.rs b/gen/oslogin1/src/lib.rs index aecbc1ce5d..68e61621ac 100644 --- a/gen/oslogin1/src/lib.rs +++ b/gen/oslogin1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/oslogin1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudOSLogin) ... +//! Handle the following *Resources* with ease from the central [hub](CloudOSLogin) ... //! //! * users //! * [*get login profile*](api::UserGetLoginProfileCall), [*import ssh public key*](api::UserImportSshPublicKeyCall), [*projects delete*](api::UserProjectDeleteCall), [*ssh public keys create*](api::UserSshPublicKeyCreateCall), [*ssh public keys delete*](api::UserSshPublicKeyDeleteCall), [*ssh public keys get*](api::UserSshPublicKeyGetCall) and [*ssh public keys patch*](api::UserSshPublicKeyPatchCall) @@ -53,8 +53,8 @@ //! let r = hub.users().import_ssh_public_key(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use oslogin1::{CloudOSLogin, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/oslogin1_beta/src/lib.rs b/gen/oslogin1_beta/src/lib.rs index 2e9136233d..f61406ff6f 100644 --- a/gen/oslogin1_beta/src/lib.rs +++ b/gen/oslogin1_beta/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/oslogin1_beta). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudOSLogin) ... +//! Handle the following *Resources* with ease from the central [hub](CloudOSLogin) ... //! //! * users //! * [*get login profile*](api::UserGetLoginProfileCall), [*import ssh public key*](api::UserImportSshPublicKeyCall), [*projects delete*](api::UserProjectDeleteCall), [*projects locations sign ssh public key*](api::UserProjectLocationSignSshPublicKeyCall), [*projects zones sign ssh public key*](api::UserProjectZoneSignSshPublicKeyCall), [*ssh public keys create*](api::UserSshPublicKeyCreateCall), [*ssh public keys delete*](api::UserSshPublicKeyDeleteCall), [*ssh public keys get*](api::UserSshPublicKeyGetCall) and [*ssh public keys patch*](api::UserSshPublicKeyPatchCall) @@ -53,8 +53,8 @@ //! let r = hub.users().import_ssh_public_key(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use oslogin1_beta::{CloudOSLogin, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/pagespeedonline2/src/api.rs b/gen/pagespeedonline2/src/api.rs index cb8fd07a62..5d2bf2e582 100644 --- a/gen/pagespeedonline2/src/api.rs +++ b/gen/pagespeedonline2/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use pagespeedonline2::{Pagespeedonline, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/pagespeedonline2/src/lib.rs b/gen/pagespeedonline2/src/lib.rs index 09211ed0c8..7e6dee10fa 100644 --- a/gen/pagespeedonline2/src/lib.rs +++ b/gen/pagespeedonline2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/pagespeedonline2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Pagespeedonline) ... +//! Handle the following *Resources* with ease from the central [hub](Pagespeedonline) ... //! //! * pagespeedapi //! * [*runpagespeed*](api::PagespeedapiRunpagespeedCall) @@ -50,8 +50,8 @@ //! let r = hub.pagespeedapi().runpagespeed(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use pagespeedonline2::{Pagespeedonline, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -125,10 +125,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -138,25 +138,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/pagespeedonline4/src/api.rs b/gen/pagespeedonline4/src/api.rs index 75ff786d54..d51fa40303 100644 --- a/gen/pagespeedonline4/src/api.rs +++ b/gen/pagespeedonline4/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use pagespeedonline4::{Pagespeedonline, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/pagespeedonline4/src/lib.rs b/gen/pagespeedonline4/src/lib.rs index 669078cf65..02bbdbb6c7 100644 --- a/gen/pagespeedonline4/src/lib.rs +++ b/gen/pagespeedonline4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/pagespeedonline4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Pagespeedonline) ... +//! Handle the following *Resources* with ease from the central [hub](Pagespeedonline) ... //! //! * pagespeedapi //! * [*runpagespeed*](api::PagespeedapiRunpagespeedCall) @@ -50,8 +50,8 @@ //! let r = hub.pagespeedapi().runpagespeed(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use pagespeedonline4::{Pagespeedonline, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/pagespeedonline5/src/lib.rs b/gen/pagespeedonline5/src/lib.rs index 99efc5eac6..8fb8648ffc 100644 --- a/gen/pagespeedonline5/src/lib.rs +++ b/gen/pagespeedonline5/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/pagespeedonline5). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PagespeedInsights) ... +//! Handle the following *Resources* with ease from the central [hub](PagespeedInsights) ... //! //! * pagespeedapi //! * [*runpagespeed*](api::PagespeedapiRunpagespeedCall) @@ -50,8 +50,8 @@ //! let r = hub.pagespeedapi().runpagespeed(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use pagespeedonline5::{PagespeedInsights, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/partners2/src/api.rs b/gen/partners2/src/api.rs index bab7f45500..f60968bcd0 100644 --- a/gen/partners2/src/api.rs +++ b/gen/partners2/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use partners2::{Partners, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/partners2/src/lib.rs b/gen/partners2/src/lib.rs index 07f51bf2e7..31be540d39 100644 --- a/gen/partners2/src/lib.rs +++ b/gen/partners2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/partners2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Partners) ... +//! Handle the following *Resources* with ease from the central [hub](Partners) ... //! //! * analytics //! * [*list*](api::AnalyticListCall) @@ -72,8 +72,8 @@ //! let r = hub.users().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -102,12 +102,12 @@ //! use std::default::Default; //! use partners2::{Partners, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -155,10 +155,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -168,25 +168,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/paymentsresellersubscription1/src/api.rs b/gen/paymentsresellersubscription1/src/api.rs index 606a76a002..10d6272933 100644 --- a/gen/paymentsresellersubscription1/src/api.rs +++ b/gen/paymentsresellersubscription1/src/api.rs @@ -65,12 +65,12 @@ impl Default for Scope { /// use std::default::Default; /// use paymentsresellersubscription1::{PaymentsResellerSubscription, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/paymentsresellersubscription1/src/lib.rs b/gen/paymentsresellersubscription1/src/lib.rs index f1712d72a6..5f62deb629 100644 --- a/gen/paymentsresellersubscription1/src/lib.rs +++ b/gen/paymentsresellersubscription1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/paymentsresellersubscription1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PaymentsResellerSubscription) ... +//! Handle the following *Resources* with ease from the central [hub](PaymentsResellerSubscription) ... //! //! * partners //! * [*products list*](api::PartnerProductListCall), [*promotions find eligible*](api::PartnerPromotionFindEligibleCall), [*promotions list*](api::PartnerPromotionListCall), [*subscriptions cancel*](api::PartnerSubscriptionCancelCall), [*subscriptions create*](api::PartnerSubscriptionCreateCall), [*subscriptions entitle*](api::PartnerSubscriptionEntitleCall), [*subscriptions extend*](api::PartnerSubscriptionExtendCall), [*subscriptions get*](api::PartnerSubscriptionGetCall), [*subscriptions provision*](api::PartnerSubscriptionProvisionCall) and [*subscriptions undo cancel*](api::PartnerSubscriptionUndoCancelCall) @@ -52,8 +52,8 @@ //! let r = hub.partners().subscriptions_provision(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use paymentsresellersubscription1::{PaymentsResellerSubscription, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/people1/src/lib.rs b/gen/people1/src/lib.rs index d5fac07c00..824d3070e5 100644 --- a/gen/people1/src/lib.rs +++ b/gen/people1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/people1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PeopleService) ... +//! Handle the following *Resources* with ease from the central [hub](PeopleService) ... //! //! * [contact groups](api::ContactGroup) //! * [*batch get*](api::ContactGroupBatchGetCall), [*create*](api::ContactGroupCreateCall), [*delete*](api::ContactGroupDeleteCall), [*get*](api::ContactGroupGetCall), [*list*](api::ContactGroupListCall), [*members modify*](api::ContactGroupMemberModifyCall) and [*update*](api::ContactGroupUpdateCall) @@ -60,8 +60,8 @@ //! let r = hub.contact_groups().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use people1::{PeopleService, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/photoslibrary1/src/lib.rs b/gen/photoslibrary1/src/lib.rs index 62e4cbf4d8..7839458586 100644 --- a/gen/photoslibrary1/src/lib.rs +++ b/gen/photoslibrary1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/photoslibrary1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PhotosLibrary) ... +//! Handle the following *Resources* with ease from the central [hub](PhotosLibrary) ... //! //! * [albums](api::Album) //! * [*add enrichment*](api::AlbumAddEnrichmentCall), [*batch add media items*](api::AlbumBatchAddMediaItemCall), [*batch remove media items*](api::AlbumBatchRemoveMediaItemCall), [*create*](api::AlbumCreateCall), [*get*](api::AlbumGetCall), [*list*](api::AlbumListCall), [*patch*](api::AlbumPatchCall), [*share*](api::AlbumShareCall) and [*unshare*](api::AlbumUnshareCall) @@ -63,8 +63,8 @@ //! let r = hub.shared_albums().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use photoslibrary1::{PhotosLibrary, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/playablelocations3/src/api.rs b/gen/playablelocations3/src/api.rs index 8c54cc1764..cdd26cd46c 100644 --- a/gen/playablelocations3/src/api.rs +++ b/gen/playablelocations3/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use playablelocations3::{PlayableLocations, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/playablelocations3/src/lib.rs b/gen/playablelocations3/src/lib.rs index f4b7f922a9..766c1caf23 100644 --- a/gen/playablelocations3/src/lib.rs +++ b/gen/playablelocations3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/playablelocations3). //! # Features //! -//! Use the following functionality with ease from the central [hub](PlayableLocations) ... +//! Use the following functionality with ease from the central [hub](PlayableLocations) ... //! //! //! * [log impressions](api::MethodLogImpressionCall) @@ -51,8 +51,8 @@ //! let r = hub.methods().log_impressions(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use playablelocations3::{PlayableLocations, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/playcustomapp1/src/lib.rs b/gen/playcustomapp1/src/lib.rs index 83adbb3bd0..ebff826cc8 100644 --- a/gen/playcustomapp1/src/lib.rs +++ b/gen/playcustomapp1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/playcustomapp1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Playcustomapp) ... +//! Handle the following *Resources* with ease from the central [hub](Playcustomapp) ... //! //! * accounts //! * [*custom apps create*](api::AccountCustomAppCreateCall) @@ -54,8 +54,8 @@ //! let r = hub.accounts().custom_apps_create(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use playcustomapp1::{Playcustomapp, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/playintegrity1/src/lib.rs b/gen/playintegrity1/src/lib.rs index c016292140..a1b94e0109 100644 --- a/gen/playintegrity1/src/lib.rs +++ b/gen/playintegrity1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/playintegrity1). //! # Features //! -//! Use the following functionality with ease from the central [hub](PlayIntegrity) ... +//! Use the following functionality with ease from the central [hub](PlayIntegrity) ... //! //! //! * [decode integrity token](api::MethodDecodeIntegrityTokenCall) @@ -49,8 +49,8 @@ //! let r = hub.methods().decode_integrity_token(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use playintegrity1::{PlayIntegrity, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -125,10 +125,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -138,25 +138,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/playmoviespartner1/src/lib.rs b/gen/playmoviespartner1/src/lib.rs index dcb6ff68ae..23cffc9d4f 100644 --- a/gen/playmoviespartner1/src/lib.rs +++ b/gen/playmoviespartner1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/playmoviespartner1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PlayMovies) ... +//! Handle the following *Resources* with ease from the central [hub](PlayMovies) ... //! //! * accounts //! * [*avails get*](api::AccountAvailGetCall), [*avails list*](api::AccountAvailListCall), [*orders get*](api::AccountOrderGetCall), [*orders list*](api::AccountOrderListCall), [*store infos country get*](api::AccountStoreInfoCountryGetCall) and [*store infos list*](api::AccountStoreInfoListCall) @@ -50,8 +50,8 @@ //! let r = hub.accounts().avails_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use playmoviespartner1::{PlayMovies, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -120,10 +120,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -133,25 +133,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/plus1/src/lib.rs b/gen/plus1/src/lib.rs index f57fdc3cda..bff95a3ae4 100644 --- a/gen/plus1/src/lib.rs +++ b/gen/plus1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/plus1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Plus) ... +//! Handle the following *Resources* with ease from the central [hub](Plus) ... //! //! * [activities](api::Activity) //! * [*get*](api::ActivityGetCall), [*list*](api::ActivityListCall) and [*search*](api::ActivitySearchCall) @@ -56,8 +56,8 @@ //! let r = hub.people().search(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use plus1::{Plus, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/plusdomains1/src/lib.rs b/gen/plusdomains1/src/lib.rs index 11856305ba..c93aa37618 100644 --- a/gen/plusdomains1/src/lib.rs +++ b/gen/plusdomains1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/plusdomains1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PlusDomains) ... +//! Handle the following *Resources* with ease from the central [hub](PlusDomains) ... //! //! * [activities](api::Activity) //! * [*get*](api::ActivityGetCall) and [*list*](api::ActivityListCall) @@ -65,8 +65,8 @@ //! let r = hub.comments().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -94,12 +94,12 @@ //! use std::default::Default; //! use plusdomains1::{PlusDomains, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -138,10 +138,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -151,25 +151,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/policyanalyzer1/src/lib.rs b/gen/policyanalyzer1/src/lib.rs index 49eaa67c72..4abc154b7f 100644 --- a/gen/policyanalyzer1/src/lib.rs +++ b/gen/policyanalyzer1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/policyanalyzer1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PolicyAnalyzer) ... +//! Handle the following *Resources* with ease from the central [hub](PolicyAnalyzer) ... //! //! * projects //! * [*locations activity types activities query*](api::ProjectLocationActivityTypeActivityQueryCall) @@ -50,8 +50,8 @@ //! let r = hub.projects().locations_activity_types_activities_query(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use policyanalyzer1::{PolicyAnalyzer, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -123,10 +123,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -136,25 +136,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/policysimulator1/src/lib.rs b/gen/policysimulator1/src/lib.rs index 4e90d6fb1e..64d8c3c091 100644 --- a/gen/policysimulator1/src/lib.rs +++ b/gen/policysimulator1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/policysimulator1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PolicySimulator) ... +//! Handle the following *Resources* with ease from the central [hub](PolicySimulator) ... //! //! * folders //! * [*locations org policy violations previews operations get*](api::FolderLocationOrgPolicyViolationsPreviewOperationGetCall), [*locations replays create*](api::FolderLocationReplayCreateCall), [*locations replays get*](api::FolderLocationReplayGetCall), [*locations replays operations get*](api::FolderLocationReplayOperationGetCall), [*locations replays operations list*](api::FolderLocationReplayOperationListCall) and [*locations replays results list*](api::FolderLocationReplayResultListCall) @@ -66,8 +66,8 @@ //! let r = hub.projects().locations_replays_create(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use policysimulator1::{PolicySimulator, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -143,10 +143,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -156,25 +156,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/policytroubleshooter1/src/lib.rs b/gen/policytroubleshooter1/src/lib.rs index cfd159f0e1..2a0aa6dceb 100644 --- a/gen/policytroubleshooter1/src/lib.rs +++ b/gen/policytroubleshooter1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/policytroubleshooter1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PolicyTroubleshooter) ... +//! Handle the following *Resources* with ease from the central [hub](PolicyTroubleshooter) ... //! //! * iam //! * [*troubleshoot*](api::IamTroubleshootCall) @@ -50,8 +50,8 @@ //! let r = hub.iam().troubleshoot(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use policytroubleshooter1::{PolicyTroubleshooter, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/prediction1d6/src/lib.rs b/gen/prediction1d6/src/lib.rs index ae46d4a981..842030a144 100644 --- a/gen/prediction1d6/src/lib.rs +++ b/gen/prediction1d6/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/prediction1d6). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Prediction) ... +//! Handle the following *Resources* with ease from the central [hub](Prediction) ... //! //! * hostedmodels //! * [*predict*](api::HostedmodelPredictCall) @@ -54,8 +54,8 @@ //! let r = hub.trainedmodels().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use prediction1d6::{Prediction, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/privateca1/src/lib.rs b/gen/privateca1/src/lib.rs index 621de1df68..0053c79703 100644 --- a/gen/privateca1/src/lib.rs +++ b/gen/privateca1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/privateca1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CertificateAuthorityService) ... +//! Handle the following *Resources* with ease from the central [hub](CertificateAuthorityService) ... //! //! * projects //! * [*locations ca pools certificate authorities activate*](api::ProjectLocationCaPoolCertificateAuthorityActivateCall), [*locations ca pools certificate authorities certificate revocation lists get*](api::ProjectLocationCaPoolCertificateAuthorityCertificateRevocationListGetCall), [*locations ca pools certificate authorities certificate revocation lists get iam policy*](api::ProjectLocationCaPoolCertificateAuthorityCertificateRevocationListGetIamPolicyCall), [*locations ca pools certificate authorities certificate revocation lists list*](api::ProjectLocationCaPoolCertificateAuthorityCertificateRevocationListListCall), [*locations ca pools certificate authorities certificate revocation lists patch*](api::ProjectLocationCaPoolCertificateAuthorityCertificateRevocationListPatchCall), [*locations ca pools certificate authorities certificate revocation lists set iam policy*](api::ProjectLocationCaPoolCertificateAuthorityCertificateRevocationListSetIamPolicyCall), [*locations ca pools certificate authorities certificate revocation lists test iam permissions*](api::ProjectLocationCaPoolCertificateAuthorityCertificateRevocationListTestIamPermissionCall), [*locations ca pools certificate authorities create*](api::ProjectLocationCaPoolCertificateAuthorityCreateCall), [*locations ca pools certificate authorities delete*](api::ProjectLocationCaPoolCertificateAuthorityDeleteCall), [*locations ca pools certificate authorities disable*](api::ProjectLocationCaPoolCertificateAuthorityDisableCall), [*locations ca pools certificate authorities enable*](api::ProjectLocationCaPoolCertificateAuthorityEnableCall), [*locations ca pools certificate authorities fetch*](api::ProjectLocationCaPoolCertificateAuthorityFetchCall), [*locations ca pools certificate authorities get*](api::ProjectLocationCaPoolCertificateAuthorityGetCall), [*locations ca pools certificate authorities list*](api::ProjectLocationCaPoolCertificateAuthorityListCall), [*locations ca pools certificate authorities patch*](api::ProjectLocationCaPoolCertificateAuthorityPatchCall), [*locations ca pools certificate authorities undelete*](api::ProjectLocationCaPoolCertificateAuthorityUndeleteCall), [*locations ca pools certificates create*](api::ProjectLocationCaPoolCertificateCreateCall), [*locations ca pools certificates get*](api::ProjectLocationCaPoolCertificateGetCall), [*locations ca pools certificates list*](api::ProjectLocationCaPoolCertificateListCall), [*locations ca pools certificates patch*](api::ProjectLocationCaPoolCertificatePatchCall), [*locations ca pools certificates revoke*](api::ProjectLocationCaPoolCertificateRevokeCall), [*locations ca pools create*](api::ProjectLocationCaPoolCreateCall), [*locations ca pools delete*](api::ProjectLocationCaPoolDeleteCall), [*locations ca pools fetch ca certs*](api::ProjectLocationCaPoolFetchCaCertCall), [*locations ca pools get*](api::ProjectLocationCaPoolGetCall), [*locations ca pools get iam policy*](api::ProjectLocationCaPoolGetIamPolicyCall), [*locations ca pools list*](api::ProjectLocationCaPoolListCall), [*locations ca pools patch*](api::ProjectLocationCaPoolPatchCall), [*locations ca pools set iam policy*](api::ProjectLocationCaPoolSetIamPolicyCall), [*locations ca pools test iam permissions*](api::ProjectLocationCaPoolTestIamPermissionCall), [*locations certificate templates create*](api::ProjectLocationCertificateTemplateCreateCall), [*locations certificate templates delete*](api::ProjectLocationCertificateTemplateDeleteCall), [*locations certificate templates get*](api::ProjectLocationCertificateTemplateGetCall), [*locations certificate templates get iam policy*](api::ProjectLocationCertificateTemplateGetIamPolicyCall), [*locations certificate templates list*](api::ProjectLocationCertificateTemplateListCall), [*locations certificate templates patch*](api::ProjectLocationCertificateTemplatePatchCall), [*locations certificate templates set iam policy*](api::ProjectLocationCertificateTemplateSetIamPolicyCall), [*locations certificate templates test iam permissions*](api::ProjectLocationCertificateTemplateTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -64,8 +64,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -93,12 +93,12 @@ //! use std::default::Default; //! use privateca1::{CertificateAuthorityService, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -138,10 +138,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -151,25 +151,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/privateca1_beta1/src/lib.rs b/gen/privateca1_beta1/src/lib.rs index 1169b03e5c..5c7bd963b2 100644 --- a/gen/privateca1_beta1/src/lib.rs +++ b/gen/privateca1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/privateca1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CertificateAuthorityService) ... +//! Handle the following *Resources* with ease from the central [hub](CertificateAuthorityService) ... //! //! * projects //! * [*locations certificate authorities certificate revocation lists get iam policy*](api::ProjectLocationCertificateAuthorityCertificateRevocationListGetIamPolicyCall), [*locations certificate authorities certificate revocation lists set iam policy*](api::ProjectLocationCertificateAuthorityCertificateRevocationListSetIamPolicyCall), [*locations certificate authorities certificate revocation lists test iam permissions*](api::ProjectLocationCertificateAuthorityCertificateRevocationListTestIamPermissionCall), [*locations certificate authorities get iam policy*](api::ProjectLocationCertificateAuthorityGetIamPolicyCall), [*locations certificate authorities set iam policy*](api::ProjectLocationCertificateAuthoritySetIamPolicyCall), [*locations certificate authorities test iam permissions*](api::ProjectLocationCertificateAuthorityTestIamPermissionCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations reusable configs get iam policy*](api::ProjectLocationReusableConfigGetIamPolicyCall), [*locations reusable configs set iam policy*](api::ProjectLocationReusableConfigSetIamPolicyCall) and [*locations reusable configs test iam permissions*](api::ProjectLocationReusableConfigTestIamPermissionCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_reusable_configs_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use privateca1_beta1::{CertificateAuthorityService, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/prod_tt_sasportal1_alpha1/src/lib.rs b/gen/prod_tt_sasportal1_alpha1/src/lib.rs index 815d229af4..bfb627269b 100644 --- a/gen/prod_tt_sasportal1_alpha1/src/lib.rs +++ b/gen/prod_tt_sasportal1_alpha1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/prod_tt_sasportal1_alpha1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SASPortalTesting) ... +//! Handle the following *Resources* with ease from the central [hub](SASPortalTesting) ... //! //! * customers //! * [*deployments create*](api::CustomerDeploymentCreateCall), [*deployments delete*](api::CustomerDeploymentDeleteCall), [*deployments devices create*](api::CustomerDeploymentDeviceCreateCall), [*deployments devices create signed*](api::CustomerDeploymentDeviceCreateSignedCall), [*deployments devices list*](api::CustomerDeploymentDeviceListCall), [*deployments get*](api::CustomerDeploymentGetCall), [*deployments list*](api::CustomerDeploymentListCall), [*deployments move*](api::CustomerDeploymentMoveCall), [*deployments patch*](api::CustomerDeploymentPatchCall), [*devices create*](api::CustomerDeviceCreateCall), [*devices create signed*](api::CustomerDeviceCreateSignedCall), [*devices delete*](api::CustomerDeviceDeleteCall), [*devices get*](api::CustomerDeviceGetCall), [*devices list*](api::CustomerDeviceListCall), [*devices move*](api::CustomerDeviceMoveCall), [*devices patch*](api::CustomerDevicePatchCall), [*devices sign device*](api::CustomerDeviceSignDeviceCall), [*devices update signed*](api::CustomerDeviceUpdateSignedCall), [*get*](api::CustomerGetCall), [*list*](api::CustomerListCall), [*list gcp project deployments*](api::CustomerListGcpProjectDeploymentCall), [*list legacy organizations*](api::CustomerListLegacyOrganizationCall), [*migrate organization*](api::CustomerMigrateOrganizationCall), [*nodes create*](api::CustomerNodeCreateCall), [*nodes delete*](api::CustomerNodeDeleteCall), [*nodes deployments create*](api::CustomerNodeDeploymentCreateCall), [*nodes deployments list*](api::CustomerNodeDeploymentListCall), [*nodes devices create*](api::CustomerNodeDeviceCreateCall), [*nodes devices create signed*](api::CustomerNodeDeviceCreateSignedCall), [*nodes devices list*](api::CustomerNodeDeviceListCall), [*nodes get*](api::CustomerNodeGetCall), [*nodes list*](api::CustomerNodeListCall), [*nodes move*](api::CustomerNodeMoveCall), [*nodes nodes create*](api::CustomerNodeNodeCreateCall), [*nodes nodes list*](api::CustomerNodeNodeListCall), [*nodes patch*](api::CustomerNodePatchCall), [*patch*](api::CustomerPatchCall), [*provision deployment*](api::CustomerProvisionDeploymentCall) and [*setup sas analytics*](api::CustomerSetupSasAnalyticCall) @@ -78,8 +78,8 @@ //! let r = hub.nodes().nodes_devices_create_signed(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -108,12 +108,12 @@ //! use std::default::Default; //! use prod_tt_sasportal1_alpha1::{SASPortalTesting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -155,10 +155,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -168,25 +168,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/proximitybeacon1_beta1/src/lib.rs b/gen/proximitybeacon1_beta1/src/lib.rs index 55f4d12547..931a11b6c2 100644 --- a/gen/proximitybeacon1_beta1/src/lib.rs +++ b/gen/proximitybeacon1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/proximitybeacon1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Proximitybeacon) ... +//! Handle the following *Resources* with ease from the central [hub](Proximitybeacon) ... //! //! * beaconinfo //! * [*getforobserved*](api::BeaconinfoGetforobservedCall) @@ -69,8 +69,8 @@ //! let r = hub.beacons().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -98,12 +98,12 @@ //! use std::default::Default; //! use proximitybeacon1_beta1::{Proximitybeacon, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -143,10 +143,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -156,25 +156,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/pubsub1/src/lib.rs b/gen/pubsub1/src/lib.rs index beb826d87d..f9d18cb6ce 100644 --- a/gen/pubsub1/src/lib.rs +++ b/gen/pubsub1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/pubsub1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Pubsub) ... +//! Handle the following *Resources* with ease from the central [hub](Pubsub) ... //! //! * projects //! * [*schemas commit*](api::ProjectSchemaCommitCall), [*schemas create*](api::ProjectSchemaCreateCall), [*schemas delete*](api::ProjectSchemaDeleteCall), [*schemas delete revision*](api::ProjectSchemaDeleteRevisionCall), [*schemas get*](api::ProjectSchemaGetCall), [*schemas get iam policy*](api::ProjectSchemaGetIamPolicyCall), [*schemas list*](api::ProjectSchemaListCall), [*schemas list revisions*](api::ProjectSchemaListRevisionCall), [*schemas rollback*](api::ProjectSchemaRollbackCall), [*schemas set iam policy*](api::ProjectSchemaSetIamPolicyCall), [*schemas test iam permissions*](api::ProjectSchemaTestIamPermissionCall), [*schemas validate*](api::ProjectSchemaValidateCall), [*schemas validate message*](api::ProjectSchemaValidateMessageCall), [*snapshots create*](api::ProjectSnapshotCreateCall), [*snapshots delete*](api::ProjectSnapshotDeleteCall), [*snapshots get*](api::ProjectSnapshotGetCall), [*snapshots get iam policy*](api::ProjectSnapshotGetIamPolicyCall), [*snapshots list*](api::ProjectSnapshotListCall), [*snapshots patch*](api::ProjectSnapshotPatchCall), [*snapshots set iam policy*](api::ProjectSnapshotSetIamPolicyCall), [*snapshots test iam permissions*](api::ProjectSnapshotTestIamPermissionCall), [*subscriptions acknowledge*](api::ProjectSubscriptionAcknowledgeCall), [*subscriptions create*](api::ProjectSubscriptionCreateCall), [*subscriptions delete*](api::ProjectSubscriptionDeleteCall), [*subscriptions detach*](api::ProjectSubscriptionDetachCall), [*subscriptions get*](api::ProjectSubscriptionGetCall), [*subscriptions get iam policy*](api::ProjectSubscriptionGetIamPolicyCall), [*subscriptions list*](api::ProjectSubscriptionListCall), [*subscriptions modify ack deadline*](api::ProjectSubscriptionModifyAckDeadlineCall), [*subscriptions modify push config*](api::ProjectSubscriptionModifyPushConfigCall), [*subscriptions patch*](api::ProjectSubscriptionPatchCall), [*subscriptions pull*](api::ProjectSubscriptionPullCall), [*subscriptions seek*](api::ProjectSubscriptionSeekCall), [*subscriptions set iam policy*](api::ProjectSubscriptionSetIamPolicyCall), [*subscriptions test iam permissions*](api::ProjectSubscriptionTestIamPermissionCall), [*topics create*](api::ProjectTopicCreateCall), [*topics delete*](api::ProjectTopicDeleteCall), [*topics get*](api::ProjectTopicGetCall), [*topics get iam policy*](api::ProjectTopicGetIamPolicyCall), [*topics list*](api::ProjectTopicListCall), [*topics patch*](api::ProjectTopicPatchCall), [*topics publish*](api::ProjectTopicPublishCall), [*topics set iam policy*](api::ProjectTopicSetIamPolicyCall), [*topics snapshots list*](api::ProjectTopicSnapshotListCall), [*topics subscriptions list*](api::ProjectTopicSubscriptionListCall) and [*topics test iam permissions*](api::ProjectTopicTestIamPermissionCall) @@ -57,8 +57,8 @@ //! let r = hub.projects().topics_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use pubsub1::{Pubsub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/pubsub1_beta2/src/lib.rs b/gen/pubsub1_beta2/src/lib.rs index cb0ecdc28d..7d4df2d782 100644 --- a/gen/pubsub1_beta2/src/lib.rs +++ b/gen/pubsub1_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/pubsub1_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Pubsub) ... +//! Handle the following *Resources* with ease from the central [hub](Pubsub) ... //! //! * projects //! * [*subscriptions acknowledge*](api::ProjectSubscriptionAcknowledgeCall), [*subscriptions create*](api::ProjectSubscriptionCreateCall), [*subscriptions delete*](api::ProjectSubscriptionDeleteCall), [*subscriptions get*](api::ProjectSubscriptionGetCall), [*subscriptions get iam policy*](api::ProjectSubscriptionGetIamPolicyCall), [*subscriptions list*](api::ProjectSubscriptionListCall), [*subscriptions modify ack deadline*](api::ProjectSubscriptionModifyAckDeadlineCall), [*subscriptions modify push config*](api::ProjectSubscriptionModifyPushConfigCall), [*subscriptions pull*](api::ProjectSubscriptionPullCall), [*subscriptions set iam policy*](api::ProjectSubscriptionSetIamPolicyCall), [*subscriptions test iam permissions*](api::ProjectSubscriptionTestIamPermissionCall), [*topics create*](api::ProjectTopicCreateCall), [*topics delete*](api::ProjectTopicDeleteCall), [*topics get*](api::ProjectTopicGetCall), [*topics get iam policy*](api::ProjectTopicGetIamPolicyCall), [*topics list*](api::ProjectTopicListCall), [*topics publish*](api::ProjectTopicPublishCall), [*topics set iam policy*](api::ProjectTopicSetIamPolicyCall), [*topics subscriptions list*](api::ProjectTopicSubscriptionListCall) and [*topics test iam permissions*](api::ProjectTopicTestIamPermissionCall) @@ -54,8 +54,8 @@ //! let r = hub.projects().topics_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use pubsub1_beta2::{Pubsub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/pubsublite1/src/lib.rs b/gen/pubsublite1/src/lib.rs index d8bf10dd7b..d1833a5b28 100644 --- a/gen/pubsublite1/src/lib.rs +++ b/gen/pubsublite1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/pubsublite1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](PubsubLite) ... +//! Handle the following *Resources* with ease from the central [hub](PubsubLite) ... //! //! * admin //! * [*projects locations operations cancel*](api::AdminProjectLocationOperationCancelCall), [*projects locations operations delete*](api::AdminProjectLocationOperationDeleteCall), [*projects locations operations get*](api::AdminProjectLocationOperationGetCall), [*projects locations operations list*](api::AdminProjectLocationOperationListCall), [*projects locations reservations create*](api::AdminProjectLocationReservationCreateCall), [*projects locations reservations delete*](api::AdminProjectLocationReservationDeleteCall), [*projects locations reservations get*](api::AdminProjectLocationReservationGetCall), [*projects locations reservations list*](api::AdminProjectLocationReservationListCall), [*projects locations reservations patch*](api::AdminProjectLocationReservationPatchCall), [*projects locations reservations topics list*](api::AdminProjectLocationReservationTopicListCall), [*projects locations subscriptions create*](api::AdminProjectLocationSubscriptionCreateCall), [*projects locations subscriptions delete*](api::AdminProjectLocationSubscriptionDeleteCall), [*projects locations subscriptions get*](api::AdminProjectLocationSubscriptionGetCall), [*projects locations subscriptions list*](api::AdminProjectLocationSubscriptionListCall), [*projects locations subscriptions patch*](api::AdminProjectLocationSubscriptionPatchCall), [*projects locations subscriptions seek*](api::AdminProjectLocationSubscriptionSeekCall), [*projects locations topics create*](api::AdminProjectLocationTopicCreateCall), [*projects locations topics delete*](api::AdminProjectLocationTopicDeleteCall), [*projects locations topics get*](api::AdminProjectLocationTopicGetCall), [*projects locations topics get partitions*](api::AdminProjectLocationTopicGetPartitionCall), [*projects locations topics list*](api::AdminProjectLocationTopicListCall), [*projects locations topics patch*](api::AdminProjectLocationTopicPatchCall) and [*projects locations topics subscriptions list*](api::AdminProjectLocationTopicSubscriptionListCall) @@ -58,8 +58,8 @@ //! let r = hub.admin().projects_locations_topics_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use pubsublite1::{PubsubLite, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/qpxexpress1/src/api.rs b/gen/qpxexpress1/src/api.rs index ec2ca1bb9a..33fe8e2d35 100644 --- a/gen/qpxexpress1/src/api.rs +++ b/gen/qpxexpress1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use qpxexpress1::{QPXExpress, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/qpxexpress1/src/lib.rs b/gen/qpxexpress1/src/lib.rs index 7652403bbc..3cc9cb3a85 100644 --- a/gen/qpxexpress1/src/lib.rs +++ b/gen/qpxexpress1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/qpxexpress1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](QPXExpress) ... +//! Handle the following *Resources* with ease from the central [hub](QPXExpress) ... //! //! * trips //! * [*search*](api::TripSearchCall) @@ -50,8 +50,8 @@ //! let r = hub.trips().search(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use qpxexpress1::{QPXExpress, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/realtimebidding1/src/lib.rs b/gen/realtimebidding1/src/lib.rs index 3c953bdc1e..2f9c078314 100644 --- a/gen/realtimebidding1/src/lib.rs +++ b/gen/realtimebidding1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/realtimebidding1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](RealTimeBidding) ... +//! Handle the following *Resources* with ease from the central [hub](RealTimeBidding) ... //! //! * [bidders](api::Bidder) //! * [*creatives list*](api::BidderCreativeListCall), [*creatives watch*](api::BidderCreativeWatchCall), [*endpoints get*](api::BidderEndpointGetCall), [*endpoints list*](api::BidderEndpointListCall), [*endpoints patch*](api::BidderEndpointPatchCall), [*get*](api::BidderGetCall), [*list*](api::BidderListCall), [*pretargeting configs activate*](api::BidderPretargetingConfigActivateCall), [*pretargeting configs add targeted apps*](api::BidderPretargetingConfigAddTargetedAppCall), [*pretargeting configs add targeted publishers*](api::BidderPretargetingConfigAddTargetedPublisherCall), [*pretargeting configs add targeted sites*](api::BidderPretargetingConfigAddTargetedSiteCall), [*pretargeting configs create*](api::BidderPretargetingConfigCreateCall), [*pretargeting configs delete*](api::BidderPretargetingConfigDeleteCall), [*pretargeting configs get*](api::BidderPretargetingConfigGetCall), [*pretargeting configs list*](api::BidderPretargetingConfigListCall), [*pretargeting configs patch*](api::BidderPretargetingConfigPatchCall), [*pretargeting configs remove targeted apps*](api::BidderPretargetingConfigRemoveTargetedAppCall), [*pretargeting configs remove targeted publishers*](api::BidderPretargetingConfigRemoveTargetedPublisherCall), [*pretargeting configs remove targeted sites*](api::BidderPretargetingConfigRemoveTargetedSiteCall), [*pretargeting configs suspend*](api::BidderPretargetingConfigSuspendCall), [*publisher connections batch approve*](api::BidderPublisherConnectionBatchApproveCall), [*publisher connections batch reject*](api::BidderPublisherConnectionBatchRejectCall), [*publisher connections get*](api::BidderPublisherConnectionGetCall) and [*publisher connections list*](api::BidderPublisherConnectionListCall) @@ -75,8 +75,8 @@ //! let r = hub.bidders().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -104,12 +104,12 @@ //! use std::default::Default; //! use realtimebidding1::{RealTimeBidding, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -149,10 +149,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -162,25 +162,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/recaptchaenterprise1/src/lib.rs b/gen/recaptchaenterprise1/src/lib.rs index 5d1b157482..7e44456201 100644 --- a/gen/recaptchaenterprise1/src/lib.rs +++ b/gen/recaptchaenterprise1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/recaptchaenterprise1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](RecaptchaEnterprise) ... +//! Handle the following *Resources* with ease from the central [hub](RecaptchaEnterprise) ... //! //! * projects //! * [*assessments annotate*](api::ProjectAssessmentAnnotateCall), [*assessments create*](api::ProjectAssessmentCreateCall), [*firewallpolicies create*](api::ProjectFirewallpolicyCreateCall), [*firewallpolicies delete*](api::ProjectFirewallpolicyDeleteCall), [*firewallpolicies get*](api::ProjectFirewallpolicyGetCall), [*firewallpolicies list*](api::ProjectFirewallpolicyListCall), [*firewallpolicies patch*](api::ProjectFirewallpolicyPatchCall), [*firewallpolicies reorder*](api::ProjectFirewallpolicyReorderCall), [*keys create*](api::ProjectKeyCreateCall), [*keys delete*](api::ProjectKeyDeleteCall), [*keys get*](api::ProjectKeyGetCall), [*keys get metrics*](api::ProjectKeyGetMetricCall), [*keys list*](api::ProjectKeyListCall), [*keys migrate*](api::ProjectKeyMigrateCall), [*keys patch*](api::ProjectKeyPatchCall), [*keys retrieve legacy secret key*](api::ProjectKeyRetrieveLegacySecretKeyCall), [*relatedaccountgroupmemberships search*](api::ProjectRelatedaccountgroupmembershipSearchCall), [*relatedaccountgroups list*](api::ProjectRelatedaccountgroupListCall) and [*relatedaccountgroups memberships list*](api::ProjectRelatedaccountgroupMembershipListCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().keys_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use recaptchaenterprise1::{RecaptchaEnterprise, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/recommendationengine1_beta1/src/lib.rs b/gen/recommendationengine1_beta1/src/lib.rs index 6a63fe1e75..42c5c2305f 100644 --- a/gen/recommendationengine1_beta1/src/lib.rs +++ b/gen/recommendationengine1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/recommendationengine1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](RecommendationsAI) ... +//! Handle the following *Resources* with ease from the central [hub](RecommendationsAI) ... //! //! * projects //! * [*locations catalogs catalog items create*](api::ProjectLocationCatalogCatalogItemCreateCall), [*locations catalogs catalog items delete*](api::ProjectLocationCatalogCatalogItemDeleteCall), [*locations catalogs catalog items get*](api::ProjectLocationCatalogCatalogItemGetCall), [*locations catalogs catalog items import*](api::ProjectLocationCatalogCatalogItemImportCall), [*locations catalogs catalog items list*](api::ProjectLocationCatalogCatalogItemListCall), [*locations catalogs catalog items patch*](api::ProjectLocationCatalogCatalogItemPatchCall), [*locations catalogs event stores operations get*](api::ProjectLocationCatalogEventStoreOperationGetCall), [*locations catalogs event stores operations list*](api::ProjectLocationCatalogEventStoreOperationListCall), [*locations catalogs event stores placements predict*](api::ProjectLocationCatalogEventStorePlacementPredictCall), [*locations catalogs event stores prediction api key registrations create*](api::ProjectLocationCatalogEventStorePredictionApiKeyRegistrationCreateCall), [*locations catalogs event stores prediction api key registrations delete*](api::ProjectLocationCatalogEventStorePredictionApiKeyRegistrationDeleteCall), [*locations catalogs event stores prediction api key registrations list*](api::ProjectLocationCatalogEventStorePredictionApiKeyRegistrationListCall), [*locations catalogs event stores user events collect*](api::ProjectLocationCatalogEventStoreUserEventCollectCall), [*locations catalogs event stores user events import*](api::ProjectLocationCatalogEventStoreUserEventImportCall), [*locations catalogs event stores user events list*](api::ProjectLocationCatalogEventStoreUserEventListCall), [*locations catalogs event stores user events purge*](api::ProjectLocationCatalogEventStoreUserEventPurgeCall), [*locations catalogs event stores user events rejoin*](api::ProjectLocationCatalogEventStoreUserEventRejoinCall), [*locations catalogs event stores user events write*](api::ProjectLocationCatalogEventStoreUserEventWriteCall), [*locations catalogs list*](api::ProjectLocationCatalogListCall), [*locations catalogs operations get*](api::ProjectLocationCatalogOperationGetCall), [*locations catalogs operations list*](api::ProjectLocationCatalogOperationListCall) and [*locations catalogs patch*](api::ProjectLocationCatalogPatchCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_catalogs_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use recommendationengine1_beta1::{RecommendationsAI, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/recommender1/src/lib.rs b/gen/recommender1/src/lib.rs index 12dd4c6415..3e48b55659 100644 --- a/gen/recommender1/src/lib.rs +++ b/gen/recommender1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/recommender1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Recommender) ... +//! Handle the following *Resources* with ease from the central [hub](Recommender) ... //! //! * billing accounts //! * [*locations insight types get config*](api::BillingAccountLocationInsightTypeGetConfigCall), [*locations insight types insights get*](api::BillingAccountLocationInsightTypeInsightGetCall), [*locations insight types insights list*](api::BillingAccountLocationInsightTypeInsightListCall), [*locations insight types insights mark accepted*](api::BillingAccountLocationInsightTypeInsightMarkAcceptedCall), [*locations insight types update config*](api::BillingAccountLocationInsightTypeUpdateConfigCall), [*locations recommenders get config*](api::BillingAccountLocationRecommenderGetConfigCall), [*locations recommenders recommendations get*](api::BillingAccountLocationRecommenderRecommendationGetCall), [*locations recommenders recommendations list*](api::BillingAccountLocationRecommenderRecommendationListCall), [*locations recommenders recommendations mark claimed*](api::BillingAccountLocationRecommenderRecommendationMarkClaimedCall), [*locations recommenders recommendations mark dismissed*](api::BillingAccountLocationRecommenderRecommendationMarkDismissedCall), [*locations recommenders recommendations mark failed*](api::BillingAccountLocationRecommenderRecommendationMarkFailedCall), [*locations recommenders recommendations mark succeeded*](api::BillingAccountLocationRecommenderRecommendationMarkSucceededCall) and [*locations recommenders update config*](api::BillingAccountLocationRecommenderUpdateConfigCall) @@ -75,8 +75,8 @@ //! let r = hub.projects().locations_recommenders_recommendations_mark_succeeded(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -105,12 +105,12 @@ //! use std::default::Default; //! use recommender1::{Recommender, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -151,10 +151,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -164,25 +164,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/recommender1_beta1/src/lib.rs b/gen/recommender1_beta1/src/lib.rs index 91a21e57ce..abe973ea31 100644 --- a/gen/recommender1_beta1/src/lib.rs +++ b/gen/recommender1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/recommender1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Recommender) ... +//! Handle the following *Resources* with ease from the central [hub](Recommender) ... //! //! * billing accounts //! * [*locations insight types get config*](api::BillingAccountLocationInsightTypeGetConfigCall), [*locations insight types insights get*](api::BillingAccountLocationInsightTypeInsightGetCall), [*locations insight types insights list*](api::BillingAccountLocationInsightTypeInsightListCall), [*locations insight types insights mark accepted*](api::BillingAccountLocationInsightTypeInsightMarkAcceptedCall), [*locations insight types update config*](api::BillingAccountLocationInsightTypeUpdateConfigCall), [*locations list*](api::BillingAccountLocationListCall), [*locations recommenders get config*](api::BillingAccountLocationRecommenderGetConfigCall), [*locations recommenders recommendations get*](api::BillingAccountLocationRecommenderRecommendationGetCall), [*locations recommenders recommendations list*](api::BillingAccountLocationRecommenderRecommendationListCall), [*locations recommenders recommendations mark claimed*](api::BillingAccountLocationRecommenderRecommendationMarkClaimedCall), [*locations recommenders recommendations mark dismissed*](api::BillingAccountLocationRecommenderRecommendationMarkDismissedCall), [*locations recommenders recommendations mark failed*](api::BillingAccountLocationRecommenderRecommendationMarkFailedCall), [*locations recommenders recommendations mark succeeded*](api::BillingAccountLocationRecommenderRecommendationMarkSucceededCall) and [*locations recommenders update config*](api::BillingAccountLocationRecommenderUpdateConfigCall) @@ -79,8 +79,8 @@ //! let r = hub.projects().locations_recommenders_recommendations_mark_succeeded(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -109,12 +109,12 @@ //! use std::default::Default; //! use recommender1_beta1::{Recommender, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -155,10 +155,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -168,25 +168,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/redis1/src/lib.rs b/gen/redis1/src/lib.rs index e92c114418..339f576629 100644 --- a/gen/redis1/src/lib.rs +++ b/gen/redis1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/redis1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudRedis) ... +//! Handle the following *Resources* with ease from the central [hub](CloudRedis) ... //! //! * projects //! * [*locations clusters create*](api::ProjectLocationClusterCreateCall), [*locations clusters delete*](api::ProjectLocationClusterDeleteCall), [*locations clusters get*](api::ProjectLocationClusterGetCall), [*locations clusters get certificate authority*](api::ProjectLocationClusterGetCertificateAuthorityCall), [*locations clusters list*](api::ProjectLocationClusterListCall), [*locations clusters patch*](api::ProjectLocationClusterPatchCall), [*locations get*](api::ProjectLocationGetCall), [*locations instances create*](api::ProjectLocationInstanceCreateCall), [*locations instances delete*](api::ProjectLocationInstanceDeleteCall), [*locations instances export*](api::ProjectLocationInstanceExportCall), [*locations instances failover*](api::ProjectLocationInstanceFailoverCall), [*locations instances get*](api::ProjectLocationInstanceGetCall), [*locations instances get auth string*](api::ProjectLocationInstanceGetAuthStringCall), [*locations instances import*](api::ProjectLocationInstanceImportCall), [*locations instances list*](api::ProjectLocationInstanceListCall), [*locations instances patch*](api::ProjectLocationInstancePatchCall), [*locations instances reschedule maintenance*](api::ProjectLocationInstanceRescheduleMaintenanceCall), [*locations instances upgrade*](api::ProjectLocationInstanceUpgradeCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall) and [*locations operations list*](api::ProjectLocationOperationListCall) @@ -61,8 +61,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use redis1::{CloudRedis, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -139,10 +139,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -152,25 +152,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/remotebuildexecution2/src/lib.rs b/gen/remotebuildexecution2/src/lib.rs index 1c282d3eeb..b9548d9e75 100644 --- a/gen/remotebuildexecution2/src/lib.rs +++ b/gen/remotebuildexecution2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/remotebuildexecution2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](RemoteBuildExecution) ... +//! Handle the following *Resources* with ease from the central [hub](RemoteBuildExecution) ... //! //! * action results //! * [*get*](api::ActionResultGetCall) and [*update*](api::ActionResultUpdateCall) @@ -60,8 +60,8 @@ //! let r = hub.action_results().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use remotebuildexecution2::{RemoteBuildExecution, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/replicapool1_beta2/src/lib.rs b/gen/replicapool1_beta2/src/lib.rs index 9457a3bde5..709ec2732c 100644 --- a/gen/replicapool1_beta2/src/lib.rs +++ b/gen/replicapool1_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/replicapool1_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Replicapool) ... +//! Handle the following *Resources* with ease from the central [hub](Replicapool) ... //! //! * [instance group managers](api::InstanceGroupManager) //! * [*abandon instances*](api::InstanceGroupManagerAbandonInstanceCall), [*delete*](api::InstanceGroupManagerDeleteCall), [*delete instances*](api::InstanceGroupManagerDeleteInstanceCall), [*get*](api::InstanceGroupManagerGetCall), [*insert*](api::InstanceGroupManagerInsertCall), [*list*](api::InstanceGroupManagerListCall), [*recreate instances*](api::InstanceGroupManagerRecreateInstanceCall), [*resize*](api::InstanceGroupManagerResizeCall), [*set instance template*](api::InstanceGroupManagerSetInstanceTemplateCall) and [*set target pools*](api::InstanceGroupManagerSetTargetPoolCall) @@ -61,8 +61,8 @@ //! let r = hub.instance_group_managers().set_target_pools(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use replicapool1_beta2::{Replicapool, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/replicapoolupdater1_beta1/src/lib.rs b/gen/replicapoolupdater1_beta1/src/lib.rs index b12181bbcd..e94ef9958b 100644 --- a/gen/replicapoolupdater1_beta1/src/lib.rs +++ b/gen/replicapoolupdater1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/replicapoolupdater1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Replicapoolupdater) ... +//! Handle the following *Resources* with ease from the central [hub](Replicapoolupdater) ... //! //! * [rolling updates](api::RollingUpdate) //! * [*cancel*](api::RollingUpdateCancelCall), [*get*](api::RollingUpdateGetCall), [*insert*](api::RollingUpdateInsertCall), [*list*](api::RollingUpdateListCall), [*list instance updates*](api::RollingUpdateListInstanceUpdateCall), [*pause*](api::RollingUpdatePauseCall), [*resume*](api::RollingUpdateResumeCall) and [*rollback*](api::RollingUpdateRollbackCall) @@ -59,8 +59,8 @@ //! let r = hub.rolling_updates().rollback(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use replicapoolupdater1_beta1::{Replicapoolupdater, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/reseller1_sandbox/src/lib.rs b/gen/reseller1_sandbox/src/lib.rs index 8788a0f6f3..4ba95f38a1 100644 --- a/gen/reseller1_sandbox/src/lib.rs +++ b/gen/reseller1_sandbox/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/reseller1_sandbox). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Reseller) ... +//! Handle the following *Resources* with ease from the central [hub](Reseller) ... //! //! * [customers](api::Customer) //! * [*get*](api::CustomerGetCall), [*insert*](api::CustomerInsertCall), [*patch*](api::CustomerPatchCall) and [*update*](api::CustomerUpdateCall) @@ -61,8 +61,8 @@ //! let r = hub.subscriptions().suspend(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use reseller1_sandbox::{Reseller, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -136,10 +136,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -149,25 +149,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/resourcesettings1/src/lib.rs b/gen/resourcesettings1/src/lib.rs index 23c7d27d66..4e71e692da 100644 --- a/gen/resourcesettings1/src/lib.rs +++ b/gen/resourcesettings1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/resourcesettings1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ResourceSettings) ... +//! Handle the following *Resources* with ease from the central [hub](ResourceSettings) ... //! //! * folders //! * [*settings get*](api::FolderSettingGetCall), [*settings list*](api::FolderSettingListCall) and [*settings patch*](api::FolderSettingPatchCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().settings_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use resourcesettings1::{ResourceSettings, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/resourceviews1_beta2/src/lib.rs b/gen/resourceviews1_beta2/src/lib.rs index 56a52562af..1d55b0fdf4 100644 --- a/gen/resourceviews1_beta2/src/lib.rs +++ b/gen/resourceviews1_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/resourceviews1_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Resourceviews) ... +//! Handle the following *Resources* with ease from the central [hub](Resourceviews) ... //! //! * zone operations //! * [*get*](api::ZoneOperationGetCall) and [*list*](api::ZoneOperationListCall) @@ -57,8 +57,8 @@ //! let r = hub.zone_views().set_service(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use resourceviews1_beta2::{Resourceviews, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/retail2/src/lib.rs b/gen/retail2/src/lib.rs index 4c9b29b11d..8be2c26320 100644 --- a/gen/retail2/src/lib.rs +++ b/gen/retail2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/retail2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudRetail) ... +//! Handle the following *Resources* with ease from the central [hub](CloudRetail) ... //! //! * projects //! * [*locations catalogs attributes config add catalog attribute*](api::ProjectLocationCatalogAttributesConfigAddCatalogAttributeCall), [*locations catalogs attributes config remove catalog attribute*](api::ProjectLocationCatalogAttributesConfigRemoveCatalogAttributeCall), [*locations catalogs attributes config replace catalog attribute*](api::ProjectLocationCatalogAttributesConfigReplaceCatalogAttributeCall), [*locations catalogs branches operations get*](api::ProjectLocationCatalogBranchOperationGetCall), [*locations catalogs branches products add fulfillment places*](api::ProjectLocationCatalogBranchProductAddFulfillmentPlaceCall), [*locations catalogs branches products add local inventories*](api::ProjectLocationCatalogBranchProductAddLocalInventoryCall), [*locations catalogs branches products create*](api::ProjectLocationCatalogBranchProductCreateCall), [*locations catalogs branches products delete*](api::ProjectLocationCatalogBranchProductDeleteCall), [*locations catalogs branches products get*](api::ProjectLocationCatalogBranchProductGetCall), [*locations catalogs branches products import*](api::ProjectLocationCatalogBranchProductImportCall), [*locations catalogs branches products list*](api::ProjectLocationCatalogBranchProductListCall), [*locations catalogs branches products patch*](api::ProjectLocationCatalogBranchProductPatchCall), [*locations catalogs branches products purge*](api::ProjectLocationCatalogBranchProductPurgeCall), [*locations catalogs branches products remove fulfillment places*](api::ProjectLocationCatalogBranchProductRemoveFulfillmentPlaceCall), [*locations catalogs branches products remove local inventories*](api::ProjectLocationCatalogBranchProductRemoveLocalInventoryCall), [*locations catalogs branches products set inventory*](api::ProjectLocationCatalogBranchProductSetInventoryCall), [*locations catalogs complete query*](api::ProjectLocationCatalogCompleteQueryCall), [*locations catalogs completion data import*](api::ProjectLocationCatalogCompletionDataImportCall), [*locations catalogs controls create*](api::ProjectLocationCatalogControlCreateCall), [*locations catalogs controls delete*](api::ProjectLocationCatalogControlDeleteCall), [*locations catalogs controls get*](api::ProjectLocationCatalogControlGetCall), [*locations catalogs controls list*](api::ProjectLocationCatalogControlListCall), [*locations catalogs controls patch*](api::ProjectLocationCatalogControlPatchCall), [*locations catalogs export analytics metrics*](api::ProjectLocationCatalogExportAnalyticsMetricCall), [*locations catalogs get attributes config*](api::ProjectLocationCatalogGetAttributesConfigCall), [*locations catalogs get completion config*](api::ProjectLocationCatalogGetCompletionConfigCall), [*locations catalogs get default branch*](api::ProjectLocationCatalogGetDefaultBranchCall), [*locations catalogs list*](api::ProjectLocationCatalogListCall), [*locations catalogs models create*](api::ProjectLocationCatalogModelCreateCall), [*locations catalogs models delete*](api::ProjectLocationCatalogModelDeleteCall), [*locations catalogs models get*](api::ProjectLocationCatalogModelGetCall), [*locations catalogs models list*](api::ProjectLocationCatalogModelListCall), [*locations catalogs models patch*](api::ProjectLocationCatalogModelPatchCall), [*locations catalogs models pause*](api::ProjectLocationCatalogModelPauseCall), [*locations catalogs models resume*](api::ProjectLocationCatalogModelResumeCall), [*locations catalogs models tune*](api::ProjectLocationCatalogModelTuneCall), [*locations catalogs operations get*](api::ProjectLocationCatalogOperationGetCall), [*locations catalogs operations list*](api::ProjectLocationCatalogOperationListCall), [*locations catalogs patch*](api::ProjectLocationCatalogPatchCall), [*locations catalogs placements predict*](api::ProjectLocationCatalogPlacementPredictCall), [*locations catalogs placements search*](api::ProjectLocationCatalogPlacementSearchCall), [*locations catalogs serving configs add control*](api::ProjectLocationCatalogServingConfigAddControlCall), [*locations catalogs serving configs create*](api::ProjectLocationCatalogServingConfigCreateCall), [*locations catalogs serving configs delete*](api::ProjectLocationCatalogServingConfigDeleteCall), [*locations catalogs serving configs get*](api::ProjectLocationCatalogServingConfigGetCall), [*locations catalogs serving configs list*](api::ProjectLocationCatalogServingConfigListCall), [*locations catalogs serving configs patch*](api::ProjectLocationCatalogServingConfigPatchCall), [*locations catalogs serving configs predict*](api::ProjectLocationCatalogServingConfigPredictCall), [*locations catalogs serving configs remove control*](api::ProjectLocationCatalogServingConfigRemoveControlCall), [*locations catalogs serving configs search*](api::ProjectLocationCatalogServingConfigSearchCall), [*locations catalogs set default branch*](api::ProjectLocationCatalogSetDefaultBranchCall), [*locations catalogs update attributes config*](api::ProjectLocationCatalogUpdateAttributesConfigCall), [*locations catalogs update completion config*](api::ProjectLocationCatalogUpdateCompletionConfigCall), [*locations catalogs user events collect*](api::ProjectLocationCatalogUserEventCollectCall), [*locations catalogs user events import*](api::ProjectLocationCatalogUserEventImportCall), [*locations catalogs user events purge*](api::ProjectLocationCatalogUserEventPurgeCall), [*locations catalogs user events rejoin*](api::ProjectLocationCatalogUserEventRejoinCall), [*locations catalogs user events write*](api::ProjectLocationCatalogUserEventWriteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*operations get*](api::ProjectOperationGetCall) and [*operations list*](api::ProjectOperationListCall) @@ -67,8 +67,8 @@ //! let r = hub.projects().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -97,12 +97,12 @@ //! use std::default::Default; //! use retail2::{CloudRetail, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -144,10 +144,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -157,25 +157,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/run1/src/lib.rs b/gen/run1/src/lib.rs index d1fc8be076..7ae62a19a4 100644 --- a/gen/run1/src/lib.rs +++ b/gen/run1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/run1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudRun) ... +//! Handle the following *Resources* with ease from the central [hub](CloudRun) ... //! //! * namespaces //! * [*authorizeddomains list*](api::NamespaceAuthorizeddomainListCall), [*configurations get*](api::NamespaceConfigurationGetCall), [*configurations list*](api::NamespaceConfigurationListCall), [*domainmappings create*](api::NamespaceDomainmappingCreateCall), [*domainmappings delete*](api::NamespaceDomainmappingDeleteCall), [*domainmappings get*](api::NamespaceDomainmappingGetCall), [*domainmappings list*](api::NamespaceDomainmappingListCall), [*executions cancel*](api::NamespaceExecutionCancelCall), [*executions delete*](api::NamespaceExecutionDeleteCall), [*executions get*](api::NamespaceExecutionGetCall), [*executions list*](api::NamespaceExecutionListCall), [*jobs create*](api::NamespaceJobCreateCall), [*jobs delete*](api::NamespaceJobDeleteCall), [*jobs get*](api::NamespaceJobGetCall), [*jobs list*](api::NamespaceJobListCall), [*jobs replace job*](api::NamespaceJobReplaceJobCall), [*jobs run*](api::NamespaceJobRunCall), [*revisions delete*](api::NamespaceRevisionDeleteCall), [*revisions get*](api::NamespaceRevisionGetCall), [*revisions list*](api::NamespaceRevisionListCall), [*routes get*](api::NamespaceRouteGetCall), [*routes list*](api::NamespaceRouteListCall), [*services create*](api::NamespaceServiceCreateCall), [*services delete*](api::NamespaceServiceDeleteCall), [*services get*](api::NamespaceServiceGetCall), [*services list*](api::NamespaceServiceListCall), [*services replace service*](api::NamespaceServiceReplaceServiceCall), [*tasks get*](api::NamespaceTaskGetCall) and [*tasks list*](api::NamespaceTaskListCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().locations_services_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use run1::{CloudRun, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/run2/src/lib.rs b/gen/run2/src/lib.rs index 5fc0a98a2b..cbad72c1fa 100644 --- a/gen/run2/src/lib.rs +++ b/gen/run2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/run2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudRun) ... +//! Handle the following *Resources* with ease from the central [hub](CloudRun) ... //! //! * projects //! * [*locations jobs create*](api::ProjectLocationJobCreateCall), [*locations jobs delete*](api::ProjectLocationJobDeleteCall), [*locations jobs executions cancel*](api::ProjectLocationJobExecutionCancelCall), [*locations jobs executions delete*](api::ProjectLocationJobExecutionDeleteCall), [*locations jobs executions get*](api::ProjectLocationJobExecutionGetCall), [*locations jobs executions list*](api::ProjectLocationJobExecutionListCall), [*locations jobs executions tasks get*](api::ProjectLocationJobExecutionTaskGetCall), [*locations jobs executions tasks list*](api::ProjectLocationJobExecutionTaskListCall), [*locations jobs get*](api::ProjectLocationJobGetCall), [*locations jobs get iam policy*](api::ProjectLocationJobGetIamPolicyCall), [*locations jobs list*](api::ProjectLocationJobListCall), [*locations jobs patch*](api::ProjectLocationJobPatchCall), [*locations jobs run*](api::ProjectLocationJobRunCall), [*locations jobs set iam policy*](api::ProjectLocationJobSetIamPolicyCall), [*locations jobs test iam permissions*](api::ProjectLocationJobTestIamPermissionCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations operations wait*](api::ProjectLocationOperationWaitCall), [*locations services create*](api::ProjectLocationServiceCreateCall), [*locations services delete*](api::ProjectLocationServiceDeleteCall), [*locations services get*](api::ProjectLocationServiceGetCall), [*locations services get iam policy*](api::ProjectLocationServiceGetIamPolicyCall), [*locations services list*](api::ProjectLocationServiceListCall), [*locations services patch*](api::ProjectLocationServicePatchCall), [*locations services revisions delete*](api::ProjectLocationServiceRevisionDeleteCall), [*locations services revisions get*](api::ProjectLocationServiceRevisionGetCall), [*locations services revisions list*](api::ProjectLocationServiceRevisionListCall), [*locations services set iam policy*](api::ProjectLocationServiceSetIamPolicyCall) and [*locations services test iam permissions*](api::ProjectLocationServiceTestIamPermissionCall) @@ -61,8 +61,8 @@ //! let r = hub.projects().locations_services_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -91,12 +91,12 @@ //! use std::default::Default; //! use run2::{CloudRun, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -139,10 +139,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -152,25 +152,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/runtimeconfig1/src/lib.rs b/gen/runtimeconfig1/src/lib.rs index da09d91e9c..b7dd570c1b 100644 --- a/gen/runtimeconfig1/src/lib.rs +++ b/gen/runtimeconfig1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/runtimeconfig1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudRuntimeConfig) ... +//! Handle the following *Resources* with ease from the central [hub](CloudRuntimeConfig) ... //! //! * [operations](api::Operation) //! * [*cancel*](api::OperationCancelCall), [*delete*](api::OperationDeleteCall) and [*list*](api::OperationListCall) @@ -52,8 +52,8 @@ //! let r = hub.operations().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use runtimeconfig1::{CloudRuntimeConfig, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -125,10 +125,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -138,25 +138,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/runtimeconfig1_beta1/src/lib.rs b/gen/runtimeconfig1_beta1/src/lib.rs index c192c0d599..697da9759d 100644 --- a/gen/runtimeconfig1_beta1/src/lib.rs +++ b/gen/runtimeconfig1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/runtimeconfig1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudRuntimeConfig) ... +//! Handle the following *Resources* with ease from the central [hub](CloudRuntimeConfig) ... //! //! * projects //! * [*configs create*](api::ProjectConfigCreateCall), [*configs delete*](api::ProjectConfigDeleteCall), [*configs get*](api::ProjectConfigGetCall), [*configs get iam policy*](api::ProjectConfigGetIamPolicyCall), [*configs list*](api::ProjectConfigListCall), [*configs operations get*](api::ProjectConfigOperationGetCall), [*configs operations test iam permissions*](api::ProjectConfigOperationTestIamPermissionCall), [*configs set iam policy*](api::ProjectConfigSetIamPolicyCall), [*configs test iam permissions*](api::ProjectConfigTestIamPermissionCall), [*configs update*](api::ProjectConfigUpdateCall), [*configs variables create*](api::ProjectConfigVariableCreateCall), [*configs variables delete*](api::ProjectConfigVariableDeleteCall), [*configs variables get*](api::ProjectConfigVariableGetCall), [*configs variables list*](api::ProjectConfigVariableListCall), [*configs variables test iam permissions*](api::ProjectConfigVariableTestIamPermissionCall), [*configs variables update*](api::ProjectConfigVariableUpdateCall), [*configs variables watch*](api::ProjectConfigVariableWatchCall), [*configs waiters create*](api::ProjectConfigWaiterCreateCall), [*configs waiters delete*](api::ProjectConfigWaiterDeleteCall), [*configs waiters get*](api::ProjectConfigWaiterGetCall), [*configs waiters list*](api::ProjectConfigWaiterListCall) and [*configs waiters test iam permissions*](api::ProjectConfigWaiterTestIamPermissionCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().configs_variables_watch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use runtimeconfig1_beta1::{CloudRuntimeConfig, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/safebrowsing4/src/api.rs b/gen/safebrowsing4/src/api.rs index 661bbb7210..5fe49d25b6 100644 --- a/gen/safebrowsing4/src/api.rs +++ b/gen/safebrowsing4/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use safebrowsing4::{Safebrowsing, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/safebrowsing4/src/lib.rs b/gen/safebrowsing4/src/lib.rs index 4c332a3311..0145f7c4d3 100644 --- a/gen/safebrowsing4/src/lib.rs +++ b/gen/safebrowsing4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/safebrowsing4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Safebrowsing) ... +//! Handle the following *Resources* with ease from the central [hub](Safebrowsing) ... //! //! * encoded full hashes //! * [*get*](api::EncodedFullHashGetCall) @@ -63,8 +63,8 @@ //! let r = hub.full_hashes().find(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use safebrowsing4::{Safebrowsing, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/sasportal1_alpha1/src/lib.rs b/gen/sasportal1_alpha1/src/lib.rs index 68b8178248..795e2eebe4 100644 --- a/gen/sasportal1_alpha1/src/lib.rs +++ b/gen/sasportal1_alpha1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/sasportal1_alpha1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Sasportal) ... +//! Handle the following *Resources* with ease from the central [hub](Sasportal) ... //! //! * customers //! * [*deployments create*](api::CustomerDeploymentCreateCall), [*deployments delete*](api::CustomerDeploymentDeleteCall), [*deployments devices create*](api::CustomerDeploymentDeviceCreateCall), [*deployments devices create signed*](api::CustomerDeploymentDeviceCreateSignedCall), [*deployments devices list*](api::CustomerDeploymentDeviceListCall), [*deployments get*](api::CustomerDeploymentGetCall), [*deployments list*](api::CustomerDeploymentListCall), [*deployments move*](api::CustomerDeploymentMoveCall), [*deployments patch*](api::CustomerDeploymentPatchCall), [*devices create*](api::CustomerDeviceCreateCall), [*devices create signed*](api::CustomerDeviceCreateSignedCall), [*devices delete*](api::CustomerDeviceDeleteCall), [*devices get*](api::CustomerDeviceGetCall), [*devices list*](api::CustomerDeviceListCall), [*devices move*](api::CustomerDeviceMoveCall), [*devices patch*](api::CustomerDevicePatchCall), [*devices sign device*](api::CustomerDeviceSignDeviceCall), [*devices update signed*](api::CustomerDeviceUpdateSignedCall), [*get*](api::CustomerGetCall), [*list*](api::CustomerListCall), [*list gcp project deployments*](api::CustomerListGcpProjectDeploymentCall), [*list legacy organizations*](api::CustomerListLegacyOrganizationCall), [*migrate organization*](api::CustomerMigrateOrganizationCall), [*nodes create*](api::CustomerNodeCreateCall), [*nodes delete*](api::CustomerNodeDeleteCall), [*nodes deployments create*](api::CustomerNodeDeploymentCreateCall), [*nodes deployments list*](api::CustomerNodeDeploymentListCall), [*nodes devices create*](api::CustomerNodeDeviceCreateCall), [*nodes devices create signed*](api::CustomerNodeDeviceCreateSignedCall), [*nodes devices list*](api::CustomerNodeDeviceListCall), [*nodes get*](api::CustomerNodeGetCall), [*nodes list*](api::CustomerNodeListCall), [*nodes move*](api::CustomerNodeMoveCall), [*nodes nodes create*](api::CustomerNodeNodeCreateCall), [*nodes nodes list*](api::CustomerNodeNodeListCall), [*nodes patch*](api::CustomerNodePatchCall), [*patch*](api::CustomerPatchCall), [*provision deployment*](api::CustomerProvisionDeploymentCall) and [*setup sas analytics*](api::CustomerSetupSasAnalyticCall) @@ -78,8 +78,8 @@ //! let r = hub.nodes().nodes_devices_create_signed(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -108,12 +108,12 @@ //! use std::default::Default; //! use sasportal1_alpha1::{Sasportal, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -155,10 +155,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -168,25 +168,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/searchconsole1/src/lib.rs b/gen/searchconsole1/src/lib.rs index a1e16e0612..dfb54142be 100644 --- a/gen/searchconsole1/src/lib.rs +++ b/gen/searchconsole1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/searchconsole1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SearchConsole) ... +//! Handle the following *Resources* with ease from the central [hub](SearchConsole) ... //! //! * searchanalytics //! * [*query*](api::SearchanalyticQueryCall) @@ -58,8 +58,8 @@ //! let r = hub.searchanalytics().query(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use searchconsole1::{SearchConsole, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -134,10 +134,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -147,25 +147,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/secretmanager1/src/lib.rs b/gen/secretmanager1/src/lib.rs index 217a812fd5..c7bea68085 100644 --- a/gen/secretmanager1/src/lib.rs +++ b/gen/secretmanager1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/secretmanager1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SecretManager) ... +//! Handle the following *Resources* with ease from the central [hub](SecretManager) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations secrets add version*](api::ProjectLocationSecretAddVersionCall), [*locations secrets create*](api::ProjectLocationSecretCreateCall), [*locations secrets delete*](api::ProjectLocationSecretDeleteCall), [*locations secrets get*](api::ProjectLocationSecretGetCall), [*locations secrets get iam policy*](api::ProjectLocationSecretGetIamPolicyCall), [*locations secrets list*](api::ProjectLocationSecretListCall), [*locations secrets patch*](api::ProjectLocationSecretPatchCall), [*locations secrets set iam policy*](api::ProjectLocationSecretSetIamPolicyCall), [*locations secrets test iam permissions*](api::ProjectLocationSecretTestIamPermissionCall), [*locations secrets versions access*](api::ProjectLocationSecretVersionAccesCall), [*locations secrets versions destroy*](api::ProjectLocationSecretVersionDestroyCall), [*locations secrets versions disable*](api::ProjectLocationSecretVersionDisableCall), [*locations secrets versions enable*](api::ProjectLocationSecretVersionEnableCall), [*locations secrets versions get*](api::ProjectLocationSecretVersionGetCall), [*locations secrets versions list*](api::ProjectLocationSecretVersionListCall), [*secrets add version*](api::ProjectSecretAddVersionCall), [*secrets create*](api::ProjectSecretCreateCall), [*secrets delete*](api::ProjectSecretDeleteCall), [*secrets get*](api::ProjectSecretGetCall), [*secrets get iam policy*](api::ProjectSecretGetIamPolicyCall), [*secrets list*](api::ProjectSecretListCall), [*secrets patch*](api::ProjectSecretPatchCall), [*secrets set iam policy*](api::ProjectSecretSetIamPolicyCall), [*secrets test iam permissions*](api::ProjectSecretTestIamPermissionCall), [*secrets versions access*](api::ProjectSecretVersionAccesCall), [*secrets versions destroy*](api::ProjectSecretVersionDestroyCall), [*secrets versions disable*](api::ProjectSecretVersionDisableCall), [*secrets versions enable*](api::ProjectSecretVersionEnableCall), [*secrets versions get*](api::ProjectSecretVersionGetCall) and [*secrets versions list*](api::ProjectSecretVersionListCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().secrets_add_version(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use secretmanager1::{SecretManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/secretmanager1_beta1/src/lib.rs b/gen/secretmanager1_beta1/src/lib.rs index 98a823f9d0..04aee10090 100644 --- a/gen/secretmanager1_beta1/src/lib.rs +++ b/gen/secretmanager1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/secretmanager1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SecretManager) ... +//! Handle the following *Resources* with ease from the central [hub](SecretManager) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*secrets add version*](api::ProjectSecretAddVersionCall), [*secrets create*](api::ProjectSecretCreateCall), [*secrets delete*](api::ProjectSecretDeleteCall), [*secrets get*](api::ProjectSecretGetCall), [*secrets get iam policy*](api::ProjectSecretGetIamPolicyCall), [*secrets list*](api::ProjectSecretListCall), [*secrets patch*](api::ProjectSecretPatchCall), [*secrets set iam policy*](api::ProjectSecretSetIamPolicyCall), [*secrets test iam permissions*](api::ProjectSecretTestIamPermissionCall), [*secrets versions access*](api::ProjectSecretVersionAccesCall), [*secrets versions destroy*](api::ProjectSecretVersionDestroyCall), [*secrets versions disable*](api::ProjectSecretVersionDisableCall), [*secrets versions enable*](api::ProjectSecretVersionEnableCall), [*secrets versions get*](api::ProjectSecretVersionGetCall) and [*secrets versions list*](api::ProjectSecretVersionListCall) @@ -54,8 +54,8 @@ //! let r = hub.projects().secrets_add_version(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use secretmanager1_beta1::{SecretManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/securitycenter1/src/lib.rs b/gen/securitycenter1/src/lib.rs index 495966a970..794d517215 100644 --- a/gen/securitycenter1/src/lib.rs +++ b/gen/securitycenter1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/securitycenter1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SecurityCommandCenter) ... +//! Handle the following *Resources* with ease from the central [hub](SecurityCommandCenter) ... //! //! * [folders](api::Folder) //! * [*assets group*](api::FolderAssetGroupCall), [*assets list*](api::FolderAssetListCall), [*assets update security marks*](api::FolderAssetUpdateSecurityMarkCall), [*big query exports create*](api::FolderBigQueryExportCreateCall), [*big query exports delete*](api::FolderBigQueryExportDeleteCall), [*big query exports get*](api::FolderBigQueryExportGetCall), [*big query exports list*](api::FolderBigQueryExportListCall), [*big query exports patch*](api::FolderBigQueryExportPatchCall), [*event threat detection settings custom modules create*](api::FolderEventThreatDetectionSettingCustomModuleCreateCall), [*event threat detection settings custom modules delete*](api::FolderEventThreatDetectionSettingCustomModuleDeleteCall), [*event threat detection settings custom modules get*](api::FolderEventThreatDetectionSettingCustomModuleGetCall), [*event threat detection settings custom modules list*](api::FolderEventThreatDetectionSettingCustomModuleListCall), [*event threat detection settings custom modules list descendant*](api::FolderEventThreatDetectionSettingCustomModuleListDescendantCall), [*event threat detection settings custom modules patch*](api::FolderEventThreatDetectionSettingCustomModulePatchCall), [*event threat detection settings effective custom modules get*](api::FolderEventThreatDetectionSettingEffectiveCustomModuleGetCall), [*event threat detection settings effective custom modules list*](api::FolderEventThreatDetectionSettingEffectiveCustomModuleListCall), [*event threat detection settings validate custom module*](api::FolderEventThreatDetectionSettingValidateCustomModuleCall), [*findings bulk mute*](api::FolderFindingBulkMuteCall), [*locations mute configs delete*](api::FolderLocationMuteConfigDeleteCall), [*locations mute configs get*](api::FolderLocationMuteConfigGetCall), [*locations mute configs patch*](api::FolderLocationMuteConfigPatchCall), [*mute configs create*](api::FolderMuteConfigCreateCall), [*mute configs delete*](api::FolderMuteConfigDeleteCall), [*mute configs get*](api::FolderMuteConfigGetCall), [*mute configs list*](api::FolderMuteConfigListCall), [*mute configs patch*](api::FolderMuteConfigPatchCall), [*notification configs create*](api::FolderNotificationConfigCreateCall), [*notification configs delete*](api::FolderNotificationConfigDeleteCall), [*notification configs get*](api::FolderNotificationConfigGetCall), [*notification configs list*](api::FolderNotificationConfigListCall), [*notification configs patch*](api::FolderNotificationConfigPatchCall), [*security health analytics settings custom modules create*](api::FolderSecurityHealthAnalyticsSettingCustomModuleCreateCall), [*security health analytics settings custom modules delete*](api::FolderSecurityHealthAnalyticsSettingCustomModuleDeleteCall), [*security health analytics settings custom modules get*](api::FolderSecurityHealthAnalyticsSettingCustomModuleGetCall), [*security health analytics settings custom modules list*](api::FolderSecurityHealthAnalyticsSettingCustomModuleListCall), [*security health analytics settings custom modules list descendant*](api::FolderSecurityHealthAnalyticsSettingCustomModuleListDescendantCall), [*security health analytics settings custom modules patch*](api::FolderSecurityHealthAnalyticsSettingCustomModulePatchCall), [*security health analytics settings custom modules simulate*](api::FolderSecurityHealthAnalyticsSettingCustomModuleSimulateCall), [*security health analytics settings effective custom modules get*](api::FolderSecurityHealthAnalyticsSettingEffectiveCustomModuleGetCall), [*security health analytics settings effective custom modules list*](api::FolderSecurityHealthAnalyticsSettingEffectiveCustomModuleListCall), [*sources findings external systems patch*](api::FolderSourceFindingExternalSystemPatchCall), [*sources findings group*](api::FolderSourceFindingGroupCall), [*sources findings list*](api::FolderSourceFindingListCall), [*sources findings patch*](api::FolderSourceFindingPatchCall), [*sources findings set mute*](api::FolderSourceFindingSetMuteCall), [*sources findings set state*](api::FolderSourceFindingSetStateCall), [*sources findings update security marks*](api::FolderSourceFindingUpdateSecurityMarkCall) and [*sources list*](api::FolderSourceListCall) @@ -101,8 +101,8 @@ //! let r = hub.folders().sources_list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -130,12 +130,12 @@ //! use std::default::Default; //! use securitycenter1::{SecurityCommandCenter, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -178,10 +178,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -191,25 +191,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/servicebroker1/src/lib.rs b/gen/servicebroker1/src/lib.rs index 4a6d6b858f..901de3d566 100644 --- a/gen/servicebroker1/src/lib.rs +++ b/gen/servicebroker1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/servicebroker1). //! # Features //! -//! Use the following functionality with ease from the central [hub](ServiceBroker) ... +//! Use the following functionality with ease from the central [hub](ServiceBroker) ... //! //! //! * [get iam policy](api::MethodGetIamPolicyCall) @@ -52,8 +52,8 @@ //! let r = hub.methods().set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use servicebroker1::{ServiceBroker, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/servicecontrol1/src/lib.rs b/gen/servicecontrol1/src/lib.rs index 1d3e6a9c6c..bba82968e3 100644 --- a/gen/servicecontrol1/src/lib.rs +++ b/gen/servicecontrol1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/servicecontrol1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ServiceControl) ... +//! Handle the following *Resources* with ease from the central [hub](ServiceControl) ... //! //! * services //! * [*allocate quota*](api::ServiceAllocateQuotaCall), [*check*](api::ServiceCheckCall) and [*report*](api::ServiceReportCall) @@ -50,8 +50,8 @@ //! let r = hub.services().check(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use servicecontrol1::{ServiceControl, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/servicecontrol2/src/lib.rs b/gen/servicecontrol2/src/lib.rs index 62757a23b1..ee370924b7 100644 --- a/gen/servicecontrol2/src/lib.rs +++ b/gen/servicecontrol2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/servicecontrol2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ServiceControl) ... +//! Handle the following *Resources* with ease from the central [hub](ServiceControl) ... //! //! * services //! * [*check*](api::ServiceCheckCall) and [*report*](api::ServiceReportCall) @@ -50,8 +50,8 @@ //! let r = hub.services().check(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use servicecontrol2::{ServiceControl, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/servicedirectory1/src/lib.rs b/gen/servicedirectory1/src/lib.rs index e7ebe093ae..7279ebbec7 100644 --- a/gen/servicedirectory1/src/lib.rs +++ b/gen/servicedirectory1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/servicedirectory1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ServiceDirectory) ... +//! Handle the following *Resources* with ease from the central [hub](ServiceDirectory) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations namespaces create*](api::ProjectLocationNamespaceCreateCall), [*locations namespaces delete*](api::ProjectLocationNamespaceDeleteCall), [*locations namespaces get*](api::ProjectLocationNamespaceGetCall), [*locations namespaces get iam policy*](api::ProjectLocationNamespaceGetIamPolicyCall), [*locations namespaces list*](api::ProjectLocationNamespaceListCall), [*locations namespaces patch*](api::ProjectLocationNamespacePatchCall), [*locations namespaces services create*](api::ProjectLocationNamespaceServiceCreateCall), [*locations namespaces services delete*](api::ProjectLocationNamespaceServiceDeleteCall), [*locations namespaces services endpoints create*](api::ProjectLocationNamespaceServiceEndpointCreateCall), [*locations namespaces services endpoints delete*](api::ProjectLocationNamespaceServiceEndpointDeleteCall), [*locations namespaces services endpoints get*](api::ProjectLocationNamespaceServiceEndpointGetCall), [*locations namespaces services endpoints list*](api::ProjectLocationNamespaceServiceEndpointListCall), [*locations namespaces services endpoints patch*](api::ProjectLocationNamespaceServiceEndpointPatchCall), [*locations namespaces services get*](api::ProjectLocationNamespaceServiceGetCall), [*locations namespaces services get iam policy*](api::ProjectLocationNamespaceServiceGetIamPolicyCall), [*locations namespaces services list*](api::ProjectLocationNamespaceServiceListCall), [*locations namespaces services patch*](api::ProjectLocationNamespaceServicePatchCall), [*locations namespaces services resolve*](api::ProjectLocationNamespaceServiceResolveCall), [*locations namespaces services set iam policy*](api::ProjectLocationNamespaceServiceSetIamPolicyCall), [*locations namespaces services test iam permissions*](api::ProjectLocationNamespaceServiceTestIamPermissionCall), [*locations namespaces set iam policy*](api::ProjectLocationNamespaceSetIamPolicyCall) and [*locations namespaces test iam permissions*](api::ProjectLocationNamespaceTestIamPermissionCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().locations_namespaces_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use servicedirectory1::{ServiceDirectory, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/servicedirectory1_beta1/src/lib.rs b/gen/servicedirectory1_beta1/src/lib.rs index d2ebdb3495..3f21017f55 100644 --- a/gen/servicedirectory1_beta1/src/lib.rs +++ b/gen/servicedirectory1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/servicedirectory1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ServiceDirectory) ... +//! Handle the following *Resources* with ease from the central [hub](ServiceDirectory) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations namespaces create*](api::ProjectLocationNamespaceCreateCall), [*locations namespaces delete*](api::ProjectLocationNamespaceDeleteCall), [*locations namespaces get*](api::ProjectLocationNamespaceGetCall), [*locations namespaces get iam policy*](api::ProjectLocationNamespaceGetIamPolicyCall), [*locations namespaces list*](api::ProjectLocationNamespaceListCall), [*locations namespaces patch*](api::ProjectLocationNamespacePatchCall), [*locations namespaces services create*](api::ProjectLocationNamespaceServiceCreateCall), [*locations namespaces services delete*](api::ProjectLocationNamespaceServiceDeleteCall), [*locations namespaces services endpoints create*](api::ProjectLocationNamespaceServiceEndpointCreateCall), [*locations namespaces services endpoints delete*](api::ProjectLocationNamespaceServiceEndpointDeleteCall), [*locations namespaces services endpoints get*](api::ProjectLocationNamespaceServiceEndpointGetCall), [*locations namespaces services endpoints list*](api::ProjectLocationNamespaceServiceEndpointListCall), [*locations namespaces services endpoints patch*](api::ProjectLocationNamespaceServiceEndpointPatchCall), [*locations namespaces services get*](api::ProjectLocationNamespaceServiceGetCall), [*locations namespaces services get iam policy*](api::ProjectLocationNamespaceServiceGetIamPolicyCall), [*locations namespaces services list*](api::ProjectLocationNamespaceServiceListCall), [*locations namespaces services patch*](api::ProjectLocationNamespaceServicePatchCall), [*locations namespaces services resolve*](api::ProjectLocationNamespaceServiceResolveCall), [*locations namespaces services set iam policy*](api::ProjectLocationNamespaceServiceSetIamPolicyCall), [*locations namespaces services test iam permissions*](api::ProjectLocationNamespaceServiceTestIamPermissionCall), [*locations namespaces set iam policy*](api::ProjectLocationNamespaceSetIamPolicyCall), [*locations namespaces test iam permissions*](api::ProjectLocationNamespaceTestIamPermissionCall), [*locations namespaces workloads get iam policy*](api::ProjectLocationNamespaceWorkloadGetIamPolicyCall), [*locations namespaces workloads set iam policy*](api::ProjectLocationNamespaceWorkloadSetIamPolicyCall) and [*locations namespaces workloads test iam permissions*](api::ProjectLocationNamespaceWorkloadTestIamPermissionCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_namespaces_set_iam_policy(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use servicedirectory1_beta1::{ServiceDirectory, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/serviceregistryalpha/src/lib.rs b/gen/serviceregistryalpha/src/lib.rs index 6609d7683a..f7ff5b91d2 100644 --- a/gen/serviceregistryalpha/src/lib.rs +++ b/gen/serviceregistryalpha/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/serviceregistryalpha). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](ServiceRegistry) ... +//! Handle the following *Resources* with ease from the central [hub](ServiceRegistry) ... //! //! * [endpoints](api::Endpoint) //! * [*delete*](api::EndpointDeleteCall), [*get*](api::EndpointGetCall), [*insert*](api::EndpointInsertCall), [*list*](api::EndpointListCall), [*patch*](api::EndpointPatchCall) and [*update*](api::EndpointUpdateCall) @@ -57,8 +57,8 @@ //! let r = hub.operations().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use serviceregistryalpha::{ServiceRegistry, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/sheets4/src/lib.rs b/gen/sheets4/src/lib.rs index 98ec82bb87..d69cabb418 100644 --- a/gen/sheets4/src/lib.rs +++ b/gen/sheets4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/sheets4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Sheets) ... +//! Handle the following *Resources* with ease from the central [hub](Sheets) ... //! //! * [spreadsheets](api::Spreadsheet) //! * [*batch update*](api::SpreadsheetBatchUpdateCall), [*create*](api::SpreadsheetCreateCall), [*developer metadata get*](api::SpreadsheetDeveloperMetadataGetCall), [*developer metadata search*](api::SpreadsheetDeveloperMetadataSearchCall), [*get*](api::SpreadsheetGetCall), [*get by data filter*](api::SpreadsheetGetByDataFilterCall), [*sheets copy to*](api::SpreadsheetSheetCopyToCall), [*values append*](api::SpreadsheetValueAppendCall), [*values batch clear*](api::SpreadsheetValueBatchClearCall), [*values batch clear by data filter*](api::SpreadsheetValueBatchClearByDataFilterCall), [*values batch get*](api::SpreadsheetValueBatchGetCall), [*values batch get by data filter*](api::SpreadsheetValueBatchGetByDataFilterCall), [*values batch update*](api::SpreadsheetValueBatchUpdateCall), [*values batch update by data filter*](api::SpreadsheetValueBatchUpdateByDataFilterCall), [*values clear*](api::SpreadsheetValueClearCall), [*values get*](api::SpreadsheetValueGetCall) and [*values update*](api::SpreadsheetValueUpdateCall) @@ -66,8 +66,8 @@ //! let r = hub.spreadsheets().get_by_data_filter(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -96,12 +96,12 @@ //! use std::default::Default; //! use sheets4::{Sheets, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -147,10 +147,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -160,25 +160,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/siteverification1/src/lib.rs b/gen/siteverification1/src/lib.rs index 9c82341fb2..71eac7cd6e 100644 --- a/gen/siteverification1/src/lib.rs +++ b/gen/siteverification1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/siteverification1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SiteVerification) ... +//! Handle the following *Resources* with ease from the central [hub](SiteVerification) ... //! //! * web resource //! * [*delete*](api::WebResourceDeleteCall), [*get*](api::WebResourceGetCall), [*get token*](api::WebResourceGetTokenCall), [*insert*](api::WebResourceInsertCall), [*list*](api::WebResourceListCall), [*patch*](api::WebResourcePatchCall) and [*update*](api::WebResourceUpdateCall) @@ -53,8 +53,8 @@ //! let r = hub.web_resource().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use siteverification1::{SiteVerification, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/smartdevicemanagement1/src/lib.rs b/gen/smartdevicemanagement1/src/lib.rs index 0a84e5f449..d4ca1361da 100644 --- a/gen/smartdevicemanagement1/src/lib.rs +++ b/gen/smartdevicemanagement1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/smartdevicemanagement1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SmartDeviceManagement) ... +//! Handle the following *Resources* with ease from the central [hub](SmartDeviceManagement) ... //! //! * enterprises //! * [*devices execute command*](api::EnterpriseDeviceExecuteCommandCall), [*devices get*](api::EnterpriseDeviceGetCall), [*devices list*](api::EnterpriseDeviceListCall), [*structures get*](api::EnterpriseStructureGetCall), [*structures list*](api::EnterpriseStructureListCall), [*structures rooms get*](api::EnterpriseStructureRoomGetCall) and [*structures rooms list*](api::EnterpriseStructureRoomListCall) @@ -50,8 +50,8 @@ //! let r = hub.enterprises().devices_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use smartdevicemanagement1::{SmartDeviceManagement, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -120,10 +120,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -133,25 +133,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/sourcerepo1/src/lib.rs b/gen/sourcerepo1/src/lib.rs index 396dabc62f..2d8192e940 100644 --- a/gen/sourcerepo1/src/lib.rs +++ b/gen/sourcerepo1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/sourcerepo1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudSourceRepositories) ... +//! Handle the following *Resources* with ease from the central [hub](CloudSourceRepositories) ... //! //! * projects //! * [*get config*](api::ProjectGetConfigCall), [*repos create*](api::ProjectRepoCreateCall), [*repos delete*](api::ProjectRepoDeleteCall), [*repos get*](api::ProjectRepoGetCall), [*repos get iam policy*](api::ProjectRepoGetIamPolicyCall), [*repos list*](api::ProjectRepoListCall), [*repos patch*](api::ProjectRepoPatchCall), [*repos set iam policy*](api::ProjectRepoSetIamPolicyCall), [*repos sync*](api::ProjectRepoSyncCall), [*repos test iam permissions*](api::ProjectRepoTestIamPermissionCall) and [*update config*](api::ProjectUpdateConfigCall) @@ -52,8 +52,8 @@ //! let r = hub.projects().repos_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use sourcerepo1::{CloudSourceRepositories, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/spectrum1_explorer/src/api.rs b/gen/spectrum1_explorer/src/api.rs index bcfff97087..62b895ce94 100644 --- a/gen/spectrum1_explorer/src/api.rs +++ b/gen/spectrum1_explorer/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use spectrum1_explorer::{Spectrum, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/spectrum1_explorer/src/lib.rs b/gen/spectrum1_explorer/src/lib.rs index 985ebcebc0..cd5cb36f6e 100644 --- a/gen/spectrum1_explorer/src/lib.rs +++ b/gen/spectrum1_explorer/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/spectrum1_explorer). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Spectrum) ... +//! Handle the following *Resources* with ease from the central [hub](Spectrum) ... //! //! * paws //! * [*get spectrum*](api::PawGetSpectrumCall), [*get spectrum batch*](api::PawGetSpectrumBatchCall), [*init*](api::PawInitCall), [*notify spectrum use*](api::PawNotifySpectrumUseCall), [*register*](api::PawRegisterCall) and [*verify device*](api::PawVerifyDeviceCall) @@ -50,8 +50,8 @@ //! let r = hub.paws().get_spectrum_batch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use spectrum1_explorer::{Spectrum, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/speech1/src/lib.rs b/gen/speech1/src/lib.rs index 15c00e2ab6..aa754da8c0 100644 --- a/gen/speech1/src/lib.rs +++ b/gen/speech1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/speech1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Speech) ... +//! Handle the following *Resources* with ease from the central [hub](Speech) ... //! //! * [operations](api::Operation) //! * [*get*](api::OperationGetCall) and [*list*](api::OperationListCall) @@ -56,8 +56,8 @@ //! let r = hub.projects().locations_custom_classes_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use speech1::{Speech, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/speech1_beta1/src/lib.rs b/gen/speech1_beta1/src/lib.rs index 64b0f82e86..e7a8e8bf71 100644 --- a/gen/speech1_beta1/src/lib.rs +++ b/gen/speech1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/speech1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Speech) ... +//! Handle the following *Resources* with ease from the central [hub](Speech) ... //! //! * [operations](api::Operation) //! * [*get*](api::OperationGetCall) and [*list*](api::OperationListCall) @@ -54,8 +54,8 @@ //! let r = hub.speech().asyncrecognize(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use speech1_beta1::{Speech, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -128,10 +128,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -141,25 +141,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/sql1_beta4/src/lib.rs b/gen/sql1_beta4/src/lib.rs index 41b56001da..ef3c2320de 100644 --- a/gen/sql1_beta4/src/lib.rs +++ b/gen/sql1_beta4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/sql1_beta4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SQLAdmin) ... +//! Handle the following *Resources* with ease from the central [hub](SQLAdmin) ... //! //! * [backup runs](api::BackupRun) //! * [*delete*](api::BackupRunDeleteCall), [*get*](api::BackupRunGetCall), [*insert*](api::BackupRunInsertCall) and [*list*](api::BackupRunListCall) @@ -97,8 +97,8 @@ //! let r = hub.users().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -127,12 +127,12 @@ //! use std::default::Default; //! use sql1_beta4::{SQLAdmin, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -175,10 +175,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -188,25 +188,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/sqladmin1/src/lib.rs b/gen/sqladmin1/src/lib.rs index bbdebb3a2a..21f1682090 100644 --- a/gen/sqladmin1/src/lib.rs +++ b/gen/sqladmin1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/sqladmin1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SQLAdmin) ... +//! Handle the following *Resources* with ease from the central [hub](SQLAdmin) ... //! //! * [backup runs](api::BackupRun) //! * [*delete*](api::BackupRunDeleteCall), [*get*](api::BackupRunGetCall), [*insert*](api::BackupRunInsertCall) and [*list*](api::BackupRunListCall) @@ -105,8 +105,8 @@ //! let r = hub.users().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -135,12 +135,12 @@ //! use std::default::Default; //! use sqladmin1::{SQLAdmin, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -183,10 +183,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -196,25 +196,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/sqladmin1_beta4/src/lib.rs b/gen/sqladmin1_beta4/src/lib.rs index 556f66d44d..a56e4d37e9 100644 --- a/gen/sqladmin1_beta4/src/lib.rs +++ b/gen/sqladmin1_beta4/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/sqladmin1_beta4). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SQLAdmin) ... +//! Handle the following *Resources* with ease from the central [hub](SQLAdmin) ... //! //! * [backup runs](api::BackupRun) //! * [*delete*](api::BackupRunDeleteCall), [*get*](api::BackupRunGetCall), [*insert*](api::BackupRunInsertCall) and [*list*](api::BackupRunListCall) @@ -105,8 +105,8 @@ //! let r = hub.users().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -135,12 +135,12 @@ //! use std::default::Default; //! use sqladmin1_beta4::{SQLAdmin, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -183,10 +183,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -196,25 +196,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/storage1/src/lib.rs b/gen/storage1/src/lib.rs index e38cb7a57d..0b93223f8b 100644 --- a/gen/storage1/src/lib.rs +++ b/gen/storage1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/storage1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Storage) ... +//! Handle the following *Resources* with ease from the central [hub](Storage) ... //! //! * anywhere caches //! * [*disable*](api::AnywhereCachDisableCall), [*get*](api::AnywhereCachGetCall), [*insert*](api::AnywhereCachInsertCall), [*list*](api::AnywhereCachListCall), [*pause*](api::AnywhereCachPauseCall), [*resume*](api::AnywhereCachResumeCall) and [*update*](api::AnywhereCachUpdateCall) @@ -97,8 +97,8 @@ //! let r = hub.objects().watch_all(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -127,12 +127,12 @@ //! use std::default::Default; //! use storage1::{Storage, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -188,10 +188,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -201,25 +201,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/storagetransfer1/src/lib.rs b/gen/storagetransfer1/src/lib.rs index 21855a0424..056ebf29d8 100644 --- a/gen/storagetransfer1/src/lib.rs +++ b/gen/storagetransfer1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/storagetransfer1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Storagetransfer) ... +//! Handle the following *Resources* with ease from the central [hub](Storagetransfer) ... //! //! * [google service accounts](api::GoogleServiceAccount) //! * [*get*](api::GoogleServiceAccountGetCall) @@ -61,8 +61,8 @@ //! let r = hub.transfer_jobs().run(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -90,12 +90,12 @@ //! use std::default::Default; //! use storagetransfer1::{Storagetransfer, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/sts1/src/api.rs b/gen/sts1/src/api.rs index 9ac654f508..03f8fe2b38 100644 --- a/gen/sts1/src/api.rs +++ b/gen/sts1/src/api.rs @@ -43,12 +43,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use sts1::{CloudSecurityToken, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/sts1/src/lib.rs b/gen/sts1/src/lib.rs index 374a75a789..9c8f984748 100644 --- a/gen/sts1/src/lib.rs +++ b/gen/sts1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/sts1). //! # Features //! -//! Use the following functionality with ease from the central [hub](CloudSecurityToken) ... +//! Use the following functionality with ease from the central [hub](CloudSecurityToken) ... //! //! //! * [introspect](api::MethodIntrospectCall) @@ -51,8 +51,8 @@ //! let r = hub.methods().introspect(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use sts1::{CloudSecurityToken, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/surveys2/src/lib.rs b/gen/surveys2/src/lib.rs index 7508f76c71..9817859810 100644 --- a/gen/surveys2/src/lib.rs +++ b/gen/surveys2/src/lib.rs @@ -6,7 +6,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/surveys2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Surveys) ... +//! Handle the following *Resources* with ease from the central [hub](Surveys) ... //! //! * results //! * [*get*](api::ResultGetCall) @@ -59,8 +59,8 @@ //! let r = hub.surveys().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use surveys2::{Surveys, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/tagmanager1/src/lib.rs b/gen/tagmanager1/src/lib.rs index 97f2b9651c..91d99819c5 100644 --- a/gen/tagmanager1/src/lib.rs +++ b/gen/tagmanager1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/tagmanager1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](TagManager) ... +//! Handle the following *Resources* with ease from the central [hub](TagManager) ... //! //! * [accounts](api::Account) //! * [*containers create*](api::AccountContainerCreateCall), [*containers delete*](api::AccountContainerDeleteCall), [*containers environments create*](api::AccountContainerEnvironmentCreateCall), [*containers environments delete*](api::AccountContainerEnvironmentDeleteCall), [*containers environments get*](api::AccountContainerEnvironmentGetCall), [*containers environments list*](api::AccountContainerEnvironmentListCall), [*containers environments update*](api::AccountContainerEnvironmentUpdateCall), [*containers folders create*](api::AccountContainerFolderCreateCall), [*containers folders delete*](api::AccountContainerFolderDeleteCall), [*containers folders entities list*](api::AccountContainerFolderEntityListCall), [*containers folders get*](api::AccountContainerFolderGetCall), [*containers folders list*](api::AccountContainerFolderListCall), [*containers folders update*](api::AccountContainerFolderUpdateCall), [*containers get*](api::AccountContainerGetCall), [*containers list*](api::AccountContainerListCall), [*containers move_folders update*](api::AccountContainerMoveFolderUpdateCall), [*containers reauthorize_environments update*](api::AccountContainerReauthorizeEnvironmentUpdateCall), [*containers tags create*](api::AccountContainerTagCreateCall), [*containers tags delete*](api::AccountContainerTagDeleteCall), [*containers tags get*](api::AccountContainerTagGetCall), [*containers tags list*](api::AccountContainerTagListCall), [*containers tags update*](api::AccountContainerTagUpdateCall), [*containers triggers create*](api::AccountContainerTriggerCreateCall), [*containers triggers delete*](api::AccountContainerTriggerDeleteCall), [*containers triggers get*](api::AccountContainerTriggerGetCall), [*containers triggers list*](api::AccountContainerTriggerListCall), [*containers triggers update*](api::AccountContainerTriggerUpdateCall), [*containers update*](api::AccountContainerUpdateCall), [*containers variables create*](api::AccountContainerVariableCreateCall), [*containers variables delete*](api::AccountContainerVariableDeleteCall), [*containers variables get*](api::AccountContainerVariableGetCall), [*containers variables list*](api::AccountContainerVariableListCall), [*containers variables update*](api::AccountContainerVariableUpdateCall), [*containers versions create*](api::AccountContainerVersionCreateCall), [*containers versions delete*](api::AccountContainerVersionDeleteCall), [*containers versions get*](api::AccountContainerVersionGetCall), [*containers versions list*](api::AccountContainerVersionListCall), [*containers versions publish*](api::AccountContainerVersionPublishCall), [*containers versions restore*](api::AccountContainerVersionRestoreCall), [*containers versions undelete*](api::AccountContainerVersionUndeleteCall), [*containers versions update*](api::AccountContainerVersionUpdateCall), [*get*](api::AccountGetCall), [*list*](api::AccountListCall), [*permissions create*](api::AccountPermissionCreateCall), [*permissions delete*](api::AccountPermissionDeleteCall), [*permissions get*](api::AccountPermissionGetCall), [*permissions list*](api::AccountPermissionListCall), [*permissions update*](api::AccountPermissionUpdateCall) and [*update*](api::AccountUpdateCall) @@ -98,8 +98,8 @@ //! let r = hub.accounts().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -128,12 +128,12 @@ //! use std::default::Default; //! use tagmanager1::{TagManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -177,10 +177,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -190,25 +190,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/tagmanager2/src/lib.rs b/gen/tagmanager2/src/lib.rs index 4e84c8c484..79e70546e7 100644 --- a/gen/tagmanager2/src/lib.rs +++ b/gen/tagmanager2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/tagmanager2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](TagManager) ... +//! Handle the following *Resources* with ease from the central [hub](TagManager) ... //! //! * [accounts](api::Account) //! * [*containers combine*](api::AccountContainerCombineCall), [*containers create*](api::AccountContainerCreateCall), [*containers delete*](api::AccountContainerDeleteCall), [*containers destinations get*](api::AccountContainerDestinationGetCall), [*containers destinations link*](api::AccountContainerDestinationLinkCall), [*containers destinations list*](api::AccountContainerDestinationListCall), [*containers environments create*](api::AccountContainerEnvironmentCreateCall), [*containers environments delete*](api::AccountContainerEnvironmentDeleteCall), [*containers environments get*](api::AccountContainerEnvironmentGetCall), [*containers environments list*](api::AccountContainerEnvironmentListCall), [*containers environments reauthorize*](api::AccountContainerEnvironmentReauthorizeCall), [*containers environments update*](api::AccountContainerEnvironmentUpdateCall), [*containers get*](api::AccountContainerGetCall), [*containers list*](api::AccountContainerListCall), [*containers lookup*](api::AccountContainerLookupCall), [*containers move_tag_id*](api::AccountContainerMoveTagIdCall), [*containers snippet*](api::AccountContainerSnippetCall), [*containers update*](api::AccountContainerUpdateCall), [*containers version_headers latest*](api::AccountContainerVersionHeaderLatestCall), [*containers version_headers list*](api::AccountContainerVersionHeaderListCall), [*containers versions delete*](api::AccountContainerVersionDeleteCall), [*containers versions get*](api::AccountContainerVersionGetCall), [*containers versions live*](api::AccountContainerVersionLiveCall), [*containers versions publish*](api::AccountContainerVersionPublishCall), [*containers versions set_latest*](api::AccountContainerVersionSetLatestCall), [*containers versions undelete*](api::AccountContainerVersionUndeleteCall), [*containers versions update*](api::AccountContainerVersionUpdateCall), [*containers workspaces built_in_variables create*](api::AccountContainerWorkspaceBuiltInVariableCreateCall), [*containers workspaces built_in_variables delete*](api::AccountContainerWorkspaceBuiltInVariableDeleteCall), [*containers workspaces built_in_variables list*](api::AccountContainerWorkspaceBuiltInVariableListCall), [*containers workspaces built_in_variables revert*](api::AccountContainerWorkspaceBuiltInVariableRevertCall), [*containers workspaces clients create*](api::AccountContainerWorkspaceClientCreateCall), [*containers workspaces clients delete*](api::AccountContainerWorkspaceClientDeleteCall), [*containers workspaces clients get*](api::AccountContainerWorkspaceClientGetCall), [*containers workspaces clients list*](api::AccountContainerWorkspaceClientListCall), [*containers workspaces clients revert*](api::AccountContainerWorkspaceClientRevertCall), [*containers workspaces clients update*](api::AccountContainerWorkspaceClientUpdateCall), [*containers workspaces create*](api::AccountContainerWorkspaceCreateCall), [*containers workspaces create_version*](api::AccountContainerWorkspaceCreateVersionCall), [*containers workspaces delete*](api::AccountContainerWorkspaceDeleteCall), [*containers workspaces folders create*](api::AccountContainerWorkspaceFolderCreateCall), [*containers workspaces folders delete*](api::AccountContainerWorkspaceFolderDeleteCall), [*containers workspaces folders entities*](api::AccountContainerWorkspaceFolderEntityCall), [*containers workspaces folders get*](api::AccountContainerWorkspaceFolderGetCall), [*containers workspaces folders list*](api::AccountContainerWorkspaceFolderListCall), [*containers workspaces folders move_entities_to_folder*](api::AccountContainerWorkspaceFolderMoveEntitiesToFolderCall), [*containers workspaces folders revert*](api::AccountContainerWorkspaceFolderRevertCall), [*containers workspaces folders update*](api::AccountContainerWorkspaceFolderUpdateCall), [*containers workspaces get*](api::AccountContainerWorkspaceGetCall), [*containers workspaces get status*](api::AccountContainerWorkspaceGetStatuCall), [*containers workspaces gtag_config create*](api::AccountContainerWorkspaceGtagConfigCreateCall), [*containers workspaces gtag_config delete*](api::AccountContainerWorkspaceGtagConfigDeleteCall), [*containers workspaces gtag_config get*](api::AccountContainerWorkspaceGtagConfigGetCall), [*containers workspaces gtag_config list*](api::AccountContainerWorkspaceGtagConfigListCall), [*containers workspaces gtag_config update*](api::AccountContainerWorkspaceGtagConfigUpdateCall), [*containers workspaces list*](api::AccountContainerWorkspaceListCall), [*containers workspaces quick_preview*](api::AccountContainerWorkspaceQuickPreviewCall), [*containers workspaces resolve_conflict*](api::AccountContainerWorkspaceResolveConflictCall), [*containers workspaces sync*](api::AccountContainerWorkspaceSyncCall), [*containers workspaces tags create*](api::AccountContainerWorkspaceTagCreateCall), [*containers workspaces tags delete*](api::AccountContainerWorkspaceTagDeleteCall), [*containers workspaces tags get*](api::AccountContainerWorkspaceTagGetCall), [*containers workspaces tags list*](api::AccountContainerWorkspaceTagListCall), [*containers workspaces tags revert*](api::AccountContainerWorkspaceTagRevertCall), [*containers workspaces tags update*](api::AccountContainerWorkspaceTagUpdateCall), [*containers workspaces templates create*](api::AccountContainerWorkspaceTemplateCreateCall), [*containers workspaces templates delete*](api::AccountContainerWorkspaceTemplateDeleteCall), [*containers workspaces templates get*](api::AccountContainerWorkspaceTemplateGetCall), [*containers workspaces templates list*](api::AccountContainerWorkspaceTemplateListCall), [*containers workspaces templates revert*](api::AccountContainerWorkspaceTemplateRevertCall), [*containers workspaces templates update*](api::AccountContainerWorkspaceTemplateUpdateCall), [*containers workspaces transformations create*](api::AccountContainerWorkspaceTransformationCreateCall), [*containers workspaces transformations delete*](api::AccountContainerWorkspaceTransformationDeleteCall), [*containers workspaces transformations get*](api::AccountContainerWorkspaceTransformationGetCall), [*containers workspaces transformations list*](api::AccountContainerWorkspaceTransformationListCall), [*containers workspaces transformations revert*](api::AccountContainerWorkspaceTransformationRevertCall), [*containers workspaces transformations update*](api::AccountContainerWorkspaceTransformationUpdateCall), [*containers workspaces triggers create*](api::AccountContainerWorkspaceTriggerCreateCall), [*containers workspaces triggers delete*](api::AccountContainerWorkspaceTriggerDeleteCall), [*containers workspaces triggers get*](api::AccountContainerWorkspaceTriggerGetCall), [*containers workspaces triggers list*](api::AccountContainerWorkspaceTriggerListCall), [*containers workspaces triggers revert*](api::AccountContainerWorkspaceTriggerRevertCall), [*containers workspaces triggers update*](api::AccountContainerWorkspaceTriggerUpdateCall), [*containers workspaces update*](api::AccountContainerWorkspaceUpdateCall), [*containers workspaces variables create*](api::AccountContainerWorkspaceVariableCreateCall), [*containers workspaces variables delete*](api::AccountContainerWorkspaceVariableDeleteCall), [*containers workspaces variables get*](api::AccountContainerWorkspaceVariableGetCall), [*containers workspaces variables list*](api::AccountContainerWorkspaceVariableListCall), [*containers workspaces variables revert*](api::AccountContainerWorkspaceVariableRevertCall), [*containers workspaces variables update*](api::AccountContainerWorkspaceVariableUpdateCall), [*containers workspaces zones create*](api::AccountContainerWorkspaceZoneCreateCall), [*containers workspaces zones delete*](api::AccountContainerWorkspaceZoneDeleteCall), [*containers workspaces zones get*](api::AccountContainerWorkspaceZoneGetCall), [*containers workspaces zones list*](api::AccountContainerWorkspaceZoneListCall), [*containers workspaces zones revert*](api::AccountContainerWorkspaceZoneRevertCall), [*containers workspaces zones update*](api::AccountContainerWorkspaceZoneUpdateCall), [*get*](api::AccountGetCall), [*list*](api::AccountListCall), [*update*](api::AccountUpdateCall), [*user_permissions create*](api::AccountUserPermissionCreateCall), [*user_permissions delete*](api::AccountUserPermissionDeleteCall), [*user_permissions get*](api::AccountUserPermissionGetCall), [*user_permissions list*](api::AccountUserPermissionListCall) and [*user_permissions update*](api::AccountUserPermissionUpdateCall) @@ -153,8 +153,8 @@ //! let r = hub.accounts().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -182,12 +182,12 @@ //! use std::default::Default; //! use tagmanager2::{TagManager, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -229,10 +229,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -242,25 +242,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/taskqueue1_beta2/src/lib.rs b/gen/taskqueue1_beta2/src/lib.rs index 5227526d50..b3972ef68a 100644 --- a/gen/taskqueue1_beta2/src/lib.rs +++ b/gen/taskqueue1_beta2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/taskqueue1_beta2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Taskqueue) ... +//! Handle the following *Resources* with ease from the central [hub](Taskqueue) ... //! //! * taskqueues //! * [*get*](api::TaskqueueGetCall) @@ -58,8 +58,8 @@ //! let r = hub.tasks().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use taskqueue1_beta2::{Taskqueue, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/tasks1/src/lib.rs b/gen/tasks1/src/lib.rs index 52969244ab..124de82aa3 100644 --- a/gen/tasks1/src/lib.rs +++ b/gen/tasks1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/tasks1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](TasksHub) ... +//! Handle the following *Resources* with ease from the central [hub](TasksHub) ... //! //! * tasklists //! * [*delete*](api::TasklistDeleteCall), [*get*](api::TasklistGetCall), [*insert*](api::TasklistInsertCall), [*list*](api::TasklistListCall), [*patch*](api::TasklistPatchCall) and [*update*](api::TasklistUpdateCall) @@ -59,8 +59,8 @@ //! let r = hub.tasks().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -88,12 +88,12 @@ //! use std::default::Default; //! use tasks1::{TasksHub, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -139,10 +139,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -152,25 +152,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/testing1/src/lib.rs b/gen/testing1/src/lib.rs index 8bf3e72c16..78d30706f2 100644 --- a/gen/testing1/src/lib.rs +++ b/gen/testing1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/testing1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Testing) ... +//! Handle the following *Resources* with ease from the central [hub](Testing) ... //! //! * application detail service //! * [*get apk details*](api::ApplicationDetailServiceGetApkDetailCall) @@ -56,8 +56,8 @@ //! let r = hub.projects().device_sessions_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -86,12 +86,12 @@ //! use std::default::Default; //! use testing1::{Testing, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/texttospeech1/src/lib.rs b/gen/texttospeech1/src/lib.rs index d6aeefe6ee..1f615ad139 100644 --- a/gen/texttospeech1/src/lib.rs +++ b/gen/texttospeech1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/texttospeech1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Texttospeech) ... +//! Handle the following *Resources* with ease from the central [hub](Texttospeech) ... //! //! * [operations](api::Operation) //! * [*cancel*](api::OperationCancelCall) and [*delete*](api::OperationDeleteCall) @@ -59,8 +59,8 @@ //! let r = hub.projects().locations_synthesize_long_audio(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -89,12 +89,12 @@ //! use std::default::Default; //! use texttospeech1::{Texttospeech, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -135,10 +135,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -148,25 +148,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/tpu1/src/lib.rs b/gen/tpu1/src/lib.rs index c189ad7cbb..2dbb8f53dc 100644 --- a/gen/tpu1/src/lib.rs +++ b/gen/tpu1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/tpu1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](TPU) ... +//! Handle the following *Resources* with ease from the central [hub](TPU) ... //! //! * projects //! * [*locations accelerator types get*](api::ProjectLocationAcceleratorTypeGetCall), [*locations accelerator types list*](api::ProjectLocationAcceleratorTypeListCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations nodes create*](api::ProjectLocationNodeCreateCall), [*locations nodes delete*](api::ProjectLocationNodeDeleteCall), [*locations nodes get*](api::ProjectLocationNodeGetCall), [*locations nodes list*](api::ProjectLocationNodeListCall), [*locations nodes reimage*](api::ProjectLocationNodeReimageCall), [*locations nodes start*](api::ProjectLocationNodeStartCall), [*locations nodes stop*](api::ProjectLocationNodeStopCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations tensorflow versions get*](api::ProjectLocationTensorflowVersionGetCall) and [*locations tensorflow versions list*](api::ProjectLocationTensorflowVersionListCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use tpu1::{TPU, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -132,10 +132,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -145,25 +145,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/tpu1_alpha1/src/lib.rs b/gen/tpu1_alpha1/src/lib.rs index 9b16191431..31b8ebc865 100644 --- a/gen/tpu1_alpha1/src/lib.rs +++ b/gen/tpu1_alpha1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/tpu1_alpha1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](TPU) ... +//! Handle the following *Resources* with ease from the central [hub](TPU) ... //! //! * projects //! * [*locations accelerator types get*](api::ProjectLocationAcceleratorTypeGetCall), [*locations accelerator types list*](api::ProjectLocationAcceleratorTypeListCall), [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations nodes create*](api::ProjectLocationNodeCreateCall), [*locations nodes delete*](api::ProjectLocationNodeDeleteCall), [*locations nodes get*](api::ProjectLocationNodeGetCall), [*locations nodes list*](api::ProjectLocationNodeListCall), [*locations nodes reimage*](api::ProjectLocationNodeReimageCall), [*locations nodes start*](api::ProjectLocationNodeStartCall), [*locations nodes stop*](api::ProjectLocationNodeStopCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations tensorflow versions get*](api::ProjectLocationTensorflowVersionGetCall) and [*locations tensorflow versions list*](api::ProjectLocationTensorflowVersionListCall) @@ -55,8 +55,8 @@ //! let r = hub.projects().locations_operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use tpu1_alpha1::{TPU, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/transcoder1/src/lib.rs b/gen/transcoder1/src/lib.rs index c75f17c9aa..2e178eb1dc 100644 --- a/gen/transcoder1/src/lib.rs +++ b/gen/transcoder1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/transcoder1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Transcoder) ... +//! Handle the following *Resources* with ease from the central [hub](Transcoder) ... //! //! * projects //! * [*locations job templates create*](api::ProjectLocationJobTemplateCreateCall), [*locations job templates delete*](api::ProjectLocationJobTemplateDeleteCall), [*locations job templates get*](api::ProjectLocationJobTemplateGetCall), [*locations job templates list*](api::ProjectLocationJobTemplateListCall), [*locations jobs create*](api::ProjectLocationJobCreateCall), [*locations jobs delete*](api::ProjectLocationJobDeleteCall), [*locations jobs get*](api::ProjectLocationJobGetCall) and [*locations jobs list*](api::ProjectLocationJobListCall) @@ -51,8 +51,8 @@ //! let r = hub.projects().locations_jobs_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use transcoder1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/transcoder1_beta1/src/lib.rs b/gen/transcoder1_beta1/src/lib.rs index bbd3cdcbc5..6f6d928911 100644 --- a/gen/transcoder1_beta1/src/lib.rs +++ b/gen/transcoder1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/transcoder1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Transcoder) ... +//! Handle the following *Resources* with ease from the central [hub](Transcoder) ... //! //! * projects //! * [*locations job templates create*](api::ProjectLocationJobTemplateCreateCall), [*locations job templates delete*](api::ProjectLocationJobTemplateDeleteCall), [*locations job templates get*](api::ProjectLocationJobTemplateGetCall), [*locations job templates list*](api::ProjectLocationJobTemplateListCall), [*locations jobs create*](api::ProjectLocationJobCreateCall), [*locations jobs delete*](api::ProjectLocationJobDeleteCall), [*locations jobs get*](api::ProjectLocationJobGetCall) and [*locations jobs list*](api::ProjectLocationJobListCall) @@ -51,8 +51,8 @@ //! let r = hub.projects().locations_jobs_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use transcoder1_beta1::{Transcoder, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/translate2/src/lib.rs b/gen/translate2/src/lib.rs index d39ce13f3a..6145e386bf 100644 --- a/gen/translate2/src/lib.rs +++ b/gen/translate2/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/translate2). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Translate) ... +//! Handle the following *Resources* with ease from the central [hub](Translate) ... //! //! * detections //! * [*detect*](api::DetectionDetectCall) and [*list*](api::DetectionListCall) @@ -55,8 +55,8 @@ //! let r = hub.detections().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -85,12 +85,12 @@ //! use std::default::Default; //! use translate2::{Translate, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -131,10 +131,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -144,25 +144,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/translate3/src/lib.rs b/gen/translate3/src/lib.rs index 969f64eb7b..5f89171a0b 100644 --- a/gen/translate3/src/lib.rs +++ b/gen/translate3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/translate3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Translate) ... +//! Handle the following *Resources* with ease from the central [hub](Translate) ... //! //! * projects //! * [*detect language*](api::ProjectDetectLanguageCall), [*get supported languages*](api::ProjectGetSupportedLanguageCall), [*locations adaptive mt datasets adaptive mt files adaptive mt sentences list*](api::ProjectLocationAdaptiveMtDatasetAdaptiveMtFileAdaptiveMtSentenceListCall), [*locations adaptive mt datasets adaptive mt files delete*](api::ProjectLocationAdaptiveMtDatasetAdaptiveMtFileDeleteCall), [*locations adaptive mt datasets adaptive mt files get*](api::ProjectLocationAdaptiveMtDatasetAdaptiveMtFileGetCall), [*locations adaptive mt datasets adaptive mt files list*](api::ProjectLocationAdaptiveMtDatasetAdaptiveMtFileListCall), [*locations adaptive mt datasets adaptive mt sentences list*](api::ProjectLocationAdaptiveMtDatasetAdaptiveMtSentenceListCall), [*locations adaptive mt datasets create*](api::ProjectLocationAdaptiveMtDatasetCreateCall), [*locations adaptive mt datasets delete*](api::ProjectLocationAdaptiveMtDatasetDeleteCall), [*locations adaptive mt datasets get*](api::ProjectLocationAdaptiveMtDatasetGetCall), [*locations adaptive mt datasets import adaptive mt file*](api::ProjectLocationAdaptiveMtDatasetImportAdaptiveMtFileCall), [*locations adaptive mt datasets list*](api::ProjectLocationAdaptiveMtDatasetListCall), [*locations adaptive mt translate*](api::ProjectLocationAdaptiveMtTranslateCall), [*locations batch translate document*](api::ProjectLocationBatchTranslateDocumentCall), [*locations batch translate text*](api::ProjectLocationBatchTranslateTextCall), [*locations datasets create*](api::ProjectLocationDatasetCreateCall), [*locations datasets delete*](api::ProjectLocationDatasetDeleteCall), [*locations datasets examples list*](api::ProjectLocationDatasetExampleListCall), [*locations datasets export data*](api::ProjectLocationDatasetExportDataCall), [*locations datasets get*](api::ProjectLocationDatasetGetCall), [*locations datasets import data*](api::ProjectLocationDatasetImportDataCall), [*locations datasets list*](api::ProjectLocationDatasetListCall), [*locations detect language*](api::ProjectLocationDetectLanguageCall), [*locations get*](api::ProjectLocationGetCall), [*locations get supported languages*](api::ProjectLocationGetSupportedLanguageCall), [*locations glossaries create*](api::ProjectLocationGlossaryCreateCall), [*locations glossaries delete*](api::ProjectLocationGlossaryDeleteCall), [*locations glossaries get*](api::ProjectLocationGlossaryGetCall), [*locations glossaries glossary entries create*](api::ProjectLocationGlossaryGlossaryEntryCreateCall), [*locations glossaries glossary entries delete*](api::ProjectLocationGlossaryGlossaryEntryDeleteCall), [*locations glossaries glossary entries get*](api::ProjectLocationGlossaryGlossaryEntryGetCall), [*locations glossaries glossary entries list*](api::ProjectLocationGlossaryGlossaryEntryListCall), [*locations glossaries glossary entries patch*](api::ProjectLocationGlossaryGlossaryEntryPatchCall), [*locations glossaries list*](api::ProjectLocationGlossaryListCall), [*locations glossaries patch*](api::ProjectLocationGlossaryPatchCall), [*locations list*](api::ProjectLocationListCall), [*locations models create*](api::ProjectLocationModelCreateCall), [*locations models delete*](api::ProjectLocationModelDeleteCall), [*locations models get*](api::ProjectLocationModelGetCall), [*locations models list*](api::ProjectLocationModelListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations operations wait*](api::ProjectLocationOperationWaitCall), [*locations romanize text*](api::ProjectLocationRomanizeTextCall), [*locations translate document*](api::ProjectLocationTranslateDocumentCall), [*locations translate text*](api::ProjectLocationTranslateTextCall), [*romanize text*](api::ProjectRomanizeTextCall) and [*translate text*](api::ProjectTranslateTextCall) @@ -62,8 +62,8 @@ //! let r = hub.projects().locations_batch_translate_text(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use translate3::{Translate, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -139,10 +139,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -152,25 +152,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/urlshortener1/src/lib.rs b/gen/urlshortener1/src/lib.rs index 47cd75db49..12a1b4d8d8 100644 --- a/gen/urlshortener1/src/lib.rs +++ b/gen/urlshortener1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/urlshortener1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Urlshortener) ... +//! Handle the following *Resources* with ease from the central [hub](Urlshortener) ... //! //! * [url](api::Url) //! * [*get*](api::UrlGetCall), [*insert*](api::UrlInsertCall) and [*list*](api::UrlListCall) @@ -51,8 +51,8 @@ //! let r = hub.url().insert(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use urlshortener1::{Urlshortener, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -122,10 +122,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -135,25 +135,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/vault1/src/lib.rs b/gen/vault1/src/lib.rs index f51886a4b1..f652d51cbd 100644 --- a/gen/vault1/src/lib.rs +++ b/gen/vault1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/vault1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Vault) ... +//! Handle the following *Resources* with ease from the central [hub](Vault) ... //! //! * [matters](api::Matter) //! * [*add permissions*](api::MatterAddPermissionCall), [*close*](api::MatterCloseCall), [*count*](api::MatterCountCall), [*create*](api::MatterCreateCall), [*delete*](api::MatterDeleteCall), [*exports create*](api::MatterExportCreateCall), [*exports delete*](api::MatterExportDeleteCall), [*exports get*](api::MatterExportGetCall), [*exports list*](api::MatterExportListCall), [*get*](api::MatterGetCall), [*holds accounts create*](api::MatterHoldAccountCreateCall), [*holds accounts delete*](api::MatterHoldAccountDeleteCall), [*holds accounts list*](api::MatterHoldAccountListCall), [*holds add held accounts*](api::MatterHoldAddHeldAccountCall), [*holds create*](api::MatterHoldCreateCall), [*holds delete*](api::MatterHoldDeleteCall), [*holds get*](api::MatterHoldGetCall), [*holds list*](api::MatterHoldListCall), [*holds remove held accounts*](api::MatterHoldRemoveHeldAccountCall), [*holds update*](api::MatterHoldUpdateCall), [*list*](api::MatterListCall), [*remove permissions*](api::MatterRemovePermissionCall), [*reopen*](api::MatterReopenCall), [*saved queries create*](api::MatterSavedQueryCreateCall), [*saved queries delete*](api::MatterSavedQueryDeleteCall), [*saved queries get*](api::MatterSavedQueryGetCall), [*saved queries list*](api::MatterSavedQueryListCall), [*undelete*](api::MatterUndeleteCall) and [*update*](api::MatterUpdateCall) @@ -80,8 +80,8 @@ //! let r = hub.matters().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -109,12 +109,12 @@ //! use std::default::Default; //! use vault1::{Vault, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -153,10 +153,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -166,25 +166,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/vectortile1/src/api.rs b/gen/vectortile1/src/api.rs index e147899490..88e06b0f39 100644 --- a/gen/vectortile1/src/api.rs +++ b/gen/vectortile1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use vectortile1::{SemanticTile, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/vectortile1/src/lib.rs b/gen/vectortile1/src/lib.rs index 5925d2da73..caf518a7bb 100644 --- a/gen/vectortile1/src/lib.rs +++ b/gen/vectortile1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/vectortile1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](SemanticTile) ... +//! Handle the following *Resources* with ease from the central [hub](SemanticTile) ... //! //! * featuretiles //! * [*get*](api::FeaturetileGetCall) @@ -52,8 +52,8 @@ //! let r = hub.featuretiles().get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -81,12 +81,12 @@ //! use std::default::Default; //! use vectortile1::{SemanticTile, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -139,10 +139,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -152,25 +152,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/verifiedaccess1/src/lib.rs b/gen/verifiedaccess1/src/lib.rs index 77a8453a74..a5947641af 100644 --- a/gen/verifiedaccess1/src/lib.rs +++ b/gen/verifiedaccess1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/verifiedaccess1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Verifiedaccess) ... +//! Handle the following *Resources* with ease from the central [hub](Verifiedaccess) ... //! //! * [challenge](api::Challenge) //! * [*create*](api::ChallengeCreateCall) and [*verify*](api::ChallengeVerifyCall) @@ -50,8 +50,8 @@ //! let r = hub.challenge().verify(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use verifiedaccess1::{Verifiedaccess, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/versionhistory1/src/api.rs b/gen/versionhistory1/src/api.rs index 239a8e5e77..19fe179fd1 100644 --- a/gen/versionhistory1/src/api.rs +++ b/gen/versionhistory1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use versionhistory1::{VersionHistory, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/versionhistory1/src/lib.rs b/gen/versionhistory1/src/lib.rs index c9f165bfea..52843a7f6c 100644 --- a/gen/versionhistory1/src/lib.rs +++ b/gen/versionhistory1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/versionhistory1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](VersionHistory) ... +//! Handle the following *Resources* with ease from the central [hub](VersionHistory) ... //! //! * [platforms](api::Platform) //! * [*channels list*](api::PlatformChannelListCall), [*channels versions list*](api::PlatformChannelVersionListCall), [*channels versions releases list*](api::PlatformChannelVersionReleaseListCall) and [*list*](api::PlatformListCall) @@ -53,8 +53,8 @@ //! let r = hub.platforms().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -82,12 +82,12 @@ //! use std::default::Default; //! use versionhistory1::{VersionHistory, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -127,10 +127,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -140,25 +140,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/videointelligence1/src/lib.rs b/gen/videointelligence1/src/lib.rs index 19b0cc68bf..c16181b50f 100644 --- a/gen/videointelligence1/src/lib.rs +++ b/gen/videointelligence1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/videointelligence1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudVideoIntelligence) ... +//! Handle the following *Resources* with ease from the central [hub](CloudVideoIntelligence) ... //! //! * operations //! * [*projects locations operations cancel*](api::OperationProjectLocationOperationCancelCall), [*projects locations operations delete*](api::OperationProjectLocationOperationDeleteCall) and [*projects locations operations get*](api::OperationProjectLocationOperationGetCall) @@ -57,8 +57,8 @@ //! let r = hub.projects().locations_operations_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use videointelligence1::{CloudVideoIntelligence, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/videointelligence1_beta1/src/lib.rs b/gen/videointelligence1_beta1/src/lib.rs index b4f99ca790..5c074ce3a5 100644 --- a/gen/videointelligence1_beta1/src/lib.rs +++ b/gen/videointelligence1_beta1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/videointelligence1_beta1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](CloudVideoIntelligence) ... +//! Handle the following *Resources* with ease from the central [hub](CloudVideoIntelligence) ... //! //! * videos //! * [*annotate*](api::VideoAnnotateCall) @@ -50,8 +50,8 @@ //! let r = hub.videos().annotate(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -80,12 +80,12 @@ //! use std::default::Default; //! use videointelligence1_beta1::{CloudVideoIntelligence, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -126,10 +126,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -139,25 +139,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/vision1/src/lib.rs b/gen/vision1/src/lib.rs index e6a7fce282..1eed9b6046 100644 --- a/gen/vision1/src/lib.rs +++ b/gen/vision1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/vision1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Vision) ... +//! Handle the following *Resources* with ease from the central [hub](Vision) ... //! //! * files //! * [*annotate*](api::FileAnnotateCall) and [*async batch annotate*](api::FileAsyncBatchAnnotateCall) @@ -72,8 +72,8 @@ //! let r = hub.projects().operations_get(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -101,12 +101,12 @@ //! use std::default::Default; //! use vision1::{Vision, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -145,10 +145,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -158,25 +158,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/vmmigration1/src/lib.rs b/gen/vmmigration1/src/lib.rs index 73c79e9e9b..6dc24f31ff 100644 --- a/gen/vmmigration1/src/lib.rs +++ b/gen/vmmigration1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/vmmigration1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](VMMigrationService) ... +//! Handle the following *Resources* with ease from the central [hub](VMMigrationService) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations groups add group migration*](api::ProjectLocationGroupAddGroupMigrationCall), [*locations groups create*](api::ProjectLocationGroupCreateCall), [*locations groups delete*](api::ProjectLocationGroupDeleteCall), [*locations groups get*](api::ProjectLocationGroupGetCall), [*locations groups list*](api::ProjectLocationGroupListCall), [*locations groups patch*](api::ProjectLocationGroupPatchCall), [*locations groups remove group migration*](api::ProjectLocationGroupRemoveGroupMigrationCall), [*locations image imports create*](api::ProjectLocationImageImportCreateCall), [*locations image imports delete*](api::ProjectLocationImageImportDeleteCall), [*locations image imports get*](api::ProjectLocationImageImportGetCall), [*locations image imports image import jobs cancel*](api::ProjectLocationImageImportImageImportJobCancelCall), [*locations image imports image import jobs get*](api::ProjectLocationImageImportImageImportJobGetCall), [*locations image imports image import jobs list*](api::ProjectLocationImageImportImageImportJobListCall), [*locations image imports list*](api::ProjectLocationImageImportListCall), [*locations list*](api::ProjectLocationListCall), [*locations operations cancel*](api::ProjectLocationOperationCancelCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations sources create*](api::ProjectLocationSourceCreateCall), [*locations sources datacenter connectors create*](api::ProjectLocationSourceDatacenterConnectorCreateCall), [*locations sources datacenter connectors delete*](api::ProjectLocationSourceDatacenterConnectorDeleteCall), [*locations sources datacenter connectors get*](api::ProjectLocationSourceDatacenterConnectorGetCall), [*locations sources datacenter connectors list*](api::ProjectLocationSourceDatacenterConnectorListCall), [*locations sources datacenter connectors upgrade appliance*](api::ProjectLocationSourceDatacenterConnectorUpgradeApplianceCall), [*locations sources delete*](api::ProjectLocationSourceDeleteCall), [*locations sources fetch inventory*](api::ProjectLocationSourceFetchInventoryCall), [*locations sources get*](api::ProjectLocationSourceGetCall), [*locations sources list*](api::ProjectLocationSourceListCall), [*locations sources migrating vms clone jobs cancel*](api::ProjectLocationSourceMigratingVmCloneJobCancelCall), [*locations sources migrating vms clone jobs create*](api::ProjectLocationSourceMigratingVmCloneJobCreateCall), [*locations sources migrating vms clone jobs get*](api::ProjectLocationSourceMigratingVmCloneJobGetCall), [*locations sources migrating vms clone jobs list*](api::ProjectLocationSourceMigratingVmCloneJobListCall), [*locations sources migrating vms create*](api::ProjectLocationSourceMigratingVmCreateCall), [*locations sources migrating vms cutover jobs cancel*](api::ProjectLocationSourceMigratingVmCutoverJobCancelCall), [*locations sources migrating vms cutover jobs create*](api::ProjectLocationSourceMigratingVmCutoverJobCreateCall), [*locations sources migrating vms cutover jobs get*](api::ProjectLocationSourceMigratingVmCutoverJobGetCall), [*locations sources migrating vms cutover jobs list*](api::ProjectLocationSourceMigratingVmCutoverJobListCall), [*locations sources migrating vms delete*](api::ProjectLocationSourceMigratingVmDeleteCall), [*locations sources migrating vms finalize migration*](api::ProjectLocationSourceMigratingVmFinalizeMigrationCall), [*locations sources migrating vms get*](api::ProjectLocationSourceMigratingVmGetCall), [*locations sources migrating vms list*](api::ProjectLocationSourceMigratingVmListCall), [*locations sources migrating vms patch*](api::ProjectLocationSourceMigratingVmPatchCall), [*locations sources migrating vms pause migration*](api::ProjectLocationSourceMigratingVmPauseMigrationCall), [*locations sources migrating vms replication cycles get*](api::ProjectLocationSourceMigratingVmReplicationCycleGetCall), [*locations sources migrating vms replication cycles list*](api::ProjectLocationSourceMigratingVmReplicationCycleListCall), [*locations sources migrating vms resume migration*](api::ProjectLocationSourceMigratingVmResumeMigrationCall), [*locations sources migrating vms start migration*](api::ProjectLocationSourceMigratingVmStartMigrationCall), [*locations sources patch*](api::ProjectLocationSourcePatchCall), [*locations sources utilization reports create*](api::ProjectLocationSourceUtilizationReportCreateCall), [*locations sources utilization reports delete*](api::ProjectLocationSourceUtilizationReportDeleteCall), [*locations sources utilization reports get*](api::ProjectLocationSourceUtilizationReportGetCall), [*locations sources utilization reports list*](api::ProjectLocationSourceUtilizationReportListCall), [*locations target projects create*](api::ProjectLocationTargetProjectCreateCall), [*locations target projects delete*](api::ProjectLocationTargetProjectDeleteCall), [*locations target projects get*](api::ProjectLocationTargetProjectGetCall), [*locations target projects list*](api::ProjectLocationTargetProjectListCall) and [*locations target projects patch*](api::ProjectLocationTargetProjectPatchCall) @@ -80,8 +80,8 @@ //! let r = hub.projects().locations_target_projects_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -110,12 +110,12 @@ //! use std::default::Default; //! use vmmigration1::{VMMigrationService, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -158,10 +158,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -171,25 +171,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/walletobjects1/src/lib.rs b/gen/walletobjects1/src/lib.rs index 3e0cfacb52..638f4b26ba 100644 --- a/gen/walletobjects1/src/lib.rs +++ b/gen/walletobjects1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/walletobjects1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Walletobjects) ... +//! Handle the following *Resources* with ease from the central [hub](Walletobjects) ... //! //! * eventticketclass //! * [*addmessage*](api::EventticketclasAddmessageCall), [*get*](api::EventticketclasGetCall), [*insert*](api::EventticketclasInsertCall), [*list*](api::EventticketclasListCall), [*patch*](api::EventticketclasPatchCall) and [*update*](api::EventticketclasUpdateCall) @@ -107,8 +107,8 @@ //! let r = hub.transitobject().addmessage(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -137,12 +137,12 @@ //! use std::default::Default; //! use walletobjects1::{Walletobjects, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -183,10 +183,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -196,25 +196,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/webfonts1/src/api.rs b/gen/webfonts1/src/api.rs index 869495d90f..c7ffcbbf2c 100644 --- a/gen/webfonts1/src/api.rs +++ b/gen/webfonts1/src/api.rs @@ -42,12 +42,12 @@ use crate::{client, client::GetToken, client::serde_with}; /// use std::default::Default; /// use webfonts1::{Webfonts, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/webfonts1/src/lib.rs b/gen/webfonts1/src/lib.rs index 2b0170989b..b13a978362 100644 --- a/gen/webfonts1/src/lib.rs +++ b/gen/webfonts1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/webfonts1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Webfonts) ... +//! Handle the following *Resources* with ease from the central [hub](Webfonts) ... //! //! * [webfonts](api::Webfont) //! * [*list*](api::WebfontListCall) @@ -50,8 +50,8 @@ //! let r = hub.webfonts().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -79,12 +79,12 @@ //! use std::default::Default; //! use webfonts1::{Webfonts, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -124,10 +124,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -137,25 +137,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/webmasters3/src/lib.rs b/gen/webmasters3/src/lib.rs index 071680b2e7..c22e826d11 100644 --- a/gen/webmasters3/src/lib.rs +++ b/gen/webmasters3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/webmasters3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Webmasters) ... +//! Handle the following *Resources* with ease from the central [hub](Webmasters) ... //! //! * searchanalytics //! * [*query*](api::SearchanalyticQueryCall) @@ -54,8 +54,8 @@ //! let r = hub.searchanalytics().query(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -84,12 +84,12 @@ //! use std::default::Default; //! use webmasters3::{Webmasters, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/webrisk1/src/lib.rs b/gen/webrisk1/src/lib.rs index 9eee0b8dcb..c53da9ed0c 100644 --- a/gen/webrisk1/src/lib.rs +++ b/gen/webrisk1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/webrisk1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](WebRisk) ... +//! Handle the following *Resources* with ease from the central [hub](WebRisk) ... //! //! * hashes //! * [*search*](api::HashSearchCall) @@ -57,8 +57,8 @@ //! let r = hub.projects().operations_delete(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -87,12 +87,12 @@ //! use std::default::Default; //! use webrisk1::{WebRisk, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -133,10 +133,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -146,25 +146,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/workflowexecutions1/src/lib.rs b/gen/workflowexecutions1/src/lib.rs index 1c81b1b0cb..c37c743ead 100644 --- a/gen/workflowexecutions1/src/lib.rs +++ b/gen/workflowexecutions1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/workflowexecutions1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](WorkflowExecutions) ... +//! Handle the following *Resources* with ease from the central [hub](WorkflowExecutions) ... //! //! * projects //! * [*locations workflows executions callbacks list*](api::ProjectLocationWorkflowExecutionCallbackListCall), [*locations workflows executions cancel*](api::ProjectLocationWorkflowExecutionCancelCall), [*locations workflows executions create*](api::ProjectLocationWorkflowExecutionCreateCall), [*locations workflows executions export data*](api::ProjectLocationWorkflowExecutionExportDataCall), [*locations workflows executions get*](api::ProjectLocationWorkflowExecutionGetCall), [*locations workflows executions list*](api::ProjectLocationWorkflowExecutionListCall), [*locations workflows executions step entries get*](api::ProjectLocationWorkflowExecutionStepEntryGetCall), [*locations workflows executions step entries list*](api::ProjectLocationWorkflowExecutionStepEntryListCall) and [*locations workflows trigger pubsub execution*](api::ProjectLocationWorkflowTriggerPubsubExecutionCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().locations_workflows_trigger_pubsub_execution(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use workflowexecutions1::{WorkflowExecutions, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -129,10 +129,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -142,25 +142,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/workflows1/src/lib.rs b/gen/workflows1/src/lib.rs index 66b0b682f4..c72b762c4a 100644 --- a/gen/workflows1/src/lib.rs +++ b/gen/workflows1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/workflows1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](Workflows) ... +//! Handle the following *Resources* with ease from the central [hub](Workflows) ... //! //! * projects //! * [*locations get*](api::ProjectLocationGetCall), [*locations list*](api::ProjectLocationListCall), [*locations operations delete*](api::ProjectLocationOperationDeleteCall), [*locations operations get*](api::ProjectLocationOperationGetCall), [*locations operations list*](api::ProjectLocationOperationListCall), [*locations workflows create*](api::ProjectLocationWorkflowCreateCall), [*locations workflows delete*](api::ProjectLocationWorkflowDeleteCall), [*locations workflows get*](api::ProjectLocationWorkflowGetCall), [*locations workflows list*](api::ProjectLocationWorkflowListCall), [*locations workflows list revisions*](api::ProjectLocationWorkflowListRevisionCall) and [*locations workflows patch*](api::ProjectLocationWorkflowPatchCall) @@ -53,8 +53,8 @@ //! let r = hub.projects().locations_workflows_patch(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -83,12 +83,12 @@ //! use std::default::Default; //! use workflows1::{Workflows, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -130,10 +130,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -143,25 +143,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/youtube3/src/api.rs b/gen/youtube3/src/api.rs index bb1e88e74e..53f54555eb 100644 --- a/gen/youtube3/src/api.rs +++ b/gen/youtube3/src/api.rs @@ -88,12 +88,12 @@ impl Default for Scope { /// use std::default::Default; /// use youtube3::{YouTube, oauth2, hyper, hyper_rustls, chrono, FieldMask}; /// -/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and +/// // Get an ApplicationSecret instance by some means. It contains the `client_id` and /// // `client_secret`, among other things. /// let secret: oauth2::ApplicationSecret = Default::default(); -/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, +/// // Instantiate the authenticator. It will choose a suitable authentication flow for you, /// // unless you replace `None` with the desired Flow. -/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +/// // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about /// // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and /// // retrieve them from storage. /// let auth = oauth2::InstalledFlowAuthenticator::builder( diff --git a/gen/youtube3/src/lib.rs b/gen/youtube3/src/lib.rs index aef40a392d..da80d2452e 100644 --- a/gen/youtube3/src/lib.rs +++ b/gen/youtube3/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/youtube3). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](YouTube) ... +//! Handle the following *Resources* with ease from the central [hub](YouTube) ... //! //! * [abuse reports](api::AbuseReport) //! * [*insert*](api::AbuseReportInsertCall) @@ -131,8 +131,8 @@ //! let r = hub.videos().update(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -160,12 +160,12 @@ //! use std::default::Default; //! use youtube3::{YouTube, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -213,10 +213,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -226,25 +226,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/gen/youtubereporting1/src/lib.rs b/gen/youtubereporting1/src/lib.rs index 20f6363801..f0d665a667 100644 --- a/gen/youtubereporting1/src/lib.rs +++ b/gen/youtubereporting1/src/lib.rs @@ -9,7 +9,7 @@ //! The original source code is [on github](https://github.com/Byron/google-apis-rs/tree/main/gen/youtubereporting1). //! # Features //! -//! Handle the following *Resources* with ease from the central [hub](YouTubeReporting) ... +//! Handle the following *Resources* with ease from the central [hub](YouTubeReporting) ... //! //! * [jobs](api::Job) //! * [*create*](api::JobCreateCall), [*delete*](api::JobDeleteCall), [*get*](api::JobGetCall), [*list*](api::JobListCall), [*reports get*](api::JobReportGetCall) and [*reports list*](api::JobReportListCall) @@ -63,8 +63,8 @@ //! let r = hub.jobs().list(...).doit().await //! ``` //! -//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +//! The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +//! supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be //! specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. //! The `doit()` method performs the actual communication with the server and returns the respective result. //! @@ -92,12 +92,12 @@ //! use std::default::Default; //! use youtubereporting1::{YouTubeReporting, oauth2, hyper, hyper_rustls, chrono, FieldMask}; //! -//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and +//! // Get an ApplicationSecret instance by some means. It contains the `client_id` and //! // `client_secret`, among other things. //! let secret: oauth2::ApplicationSecret = Default::default(); -//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, +//! // Instantiate the authenticator. It will choose a suitable authentication flow for you, //! // unless you replace `None` with the desired Flow. -//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +//! // Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about //! // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and //! // retrieve them from storage. //! let auth = oauth2::InstalledFlowAuthenticator::builder( @@ -139,10 +139,10 @@ //! ## Handling Errors //! //! All errors produced by the system are provided either as [Result](client::Result) enumeration as return value of -//! the doit() methods, or handed as possibly intermediate results to either the +//! the doit() methods, or handed as possibly intermediate results to either the //! [Hub Delegate](client::Delegate), or the [Authenticator Delegate](https://docs.rs/yup-oauth2/*/yup_oauth2/trait.AuthenticatorDelegate.html). //! -//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +//! When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This //! makes the system potentially resilient to all kinds of errors. //! //! ## Uploads and Downloads @@ -152,25 +152,25 @@ //! You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making //! this call: `.param("alt", "media")`. //! -//! Methods supporting uploads can do so using up to 2 different protocols: -//! *simple* and *resumable*. The distinctiveness of each is represented by customized +//! Methods supporting uploads can do so using up to 2 different protocols: +//! *simple* and *resumable*. The distinctiveness of each is represented by customized //! `doit(...)` methods, which are then named `upload(...)` and `upload_resumable(...)` respectively. //! //! ## Customization and Callbacks //! -//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the -//! [Method Builder](client::CallBuilder) before making the final `doit()` call. -//! Respective methods will be called to provide progress information, as well as determine whether the system should +//! You may alter the way an `doit()` method is called by providing a [delegate](client::Delegate) to the +//! [Method Builder](client::CallBuilder) before making the final `doit()` call. +//! Respective methods will be called to provide progress information, as well as determine whether the system should //! retry on failure. //! //! The [delegate trait](client::Delegate) is default-implemented, allowing you to customize it with minimal effort. //! //! ## Optional Parts in Server-Requests //! -//! All structures provided by this library are made to be [encodable](client::RequestValue) and -//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses +//! All structures provided by this library are made to be [encodable](client::RequestValue) and +//! [decodable](client::ResponseResult) via *json*. Optionals are used to indicate that partial requests are responses //! are valid. -//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to +//! Most optionals are are considered [Parts](client::Part) which are identifiable by name, which will be sent to //! the server to indicate either the set parts of the request or the desired parts in the response. //! //! ## Builder Arguments diff --git a/src/generator/templates/api/lib/lib.mako b/src/generator/templates/api/lib/lib.mako index 267952930d..bc0374f3f9 100644 --- a/src/generator/templates/api/lib/lib.mako +++ b/src/generator/templates/api/lib/lib.mako @@ -2,12 +2,12 @@ from generator.lib.util import (activity_split, put_and, md_italic, split_camelcase_s, canonical_type_name, hub_type, rust_test_fn_invisible, rust_doc_test_norun, rust_doc_comment, markdown_rust_block, unindent_first_by, mangle_ident, mb_type, singular, scope_url_to_variant, - PART_MARKER_TRAIT, RESOURCE_MARKER_TRAIT, CALL_BUILDER_MARKERT_TRAIT, + PART_MARKER_TRAIT, RESOURCE_MARKER_TRAIT, CALL_BUILDER_MARKERT_TRAIT, find_fattest_resource, build_all_params, pass_through, parts_from_params, REQUEST_MARKER_TRAIT, RESPONSE_MARKER_TRAIT, supports_scopes, to_api_version, to_fqan, METHODS_RESOURCE, ADD_PARAM_MEDIA_EXAMPLE, PROTOCOL_TYPE_INFO, enclose_in, upload_action_fn, METHODS_BUILDER_MARKER_TRAIT, DELEGATE_TYPE, - to_extern_crate_name, rust_doc_sanitize) + to_extern_crate_name, rust_doc_sanitize) def pretty_name(name): return ' '.join(split_camelcase_s(name).split('.')) @@ -15,7 +15,7 @@ <%namespace name="util" file="../../../lib/util.mako"/>\ <%namespace name="mbuild" file="mbuild.mako"/>\ -## If rust-doc is True, examples will be made to work for rust doc tests. Otherwise they are set +## If rust-doc is True, examples will be made to work for rust doc tests. Otherwise they are set ## for github markdown. ############################################################################################### ############################################################################################### @@ -69,9 +69,9 @@ The original source code is [on github](${util.github_source_root_url()}). # Features % if len(c.rta_map) > 0 + (METHODS_RESOURCE in c.rta_map): -Handle the following *Resources* with ease from the central ${link('hub', hub_url)} ... +Handle the following *Resources* with ease from the central ${link('hub', hub_url)} ... % elif METHODS_RESOURCE in c.rta_map: -Use the following functionality with ease from the central ${link('hub', hub_url)} ... +Use the following functionality with ease from the central ${link('hub', hub_url)} ... % else: It seems there is nothing you can do here ... . % endif @@ -109,7 +109,7 @@ Other activities are ... ${method_type} supported by ... % for m in methods: -<% +<% _, resource, method = activity_split(m.id) name_parts = [pretty_name(method)] if resource != METHODS_RESOURCE: @@ -162,8 +162,8 @@ let r = hub.${mangle_ident(resource)}().${mangle_ident(activity)}(...).${api.ter ``` % endif -The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` -supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be +The `resource()` and `activity(...)` calls create [builders][builder-pattern]. The second one dealing with `Activities` +supports various methods to configure the impending operation (not shown here). It is made such that all required arguments have to be specified right away (i.e. `(...)`), whereas all optional ones can be [build up][builder-pattern] as desired. The `${api.terms.action}()` method performs the actual communication with the server and returns the respective result. @@ -187,10 +187,10 @@ ${self.hub_usage_example(c, rust_doc, fr=fr)}\ ${'##'} Handling Errors All errors produced by the system are provided either as ${link('Result', 'client::Result')} enumeration as return value of -the ${api.terms.action}() methods, or handed as possibly intermediate results to either the +the ${api.terms.action}() methods, or handed as possibly intermediate results to either the ${link('Hub Delegate', delegate_url)}, or the ${link('Authenticator Delegate', urls.authenticator_delegate)}. -When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This +When delegates handle errors or intermediate values, they may have a chance to instruct the system to retry. This makes the system potentially resilient to all kinds of errors. ${'##'} Uploads and Downloads @@ -200,25 +200,25 @@ If such a method also supports a ${link('Response Result', 'client::ResponseResu You can see it as meta-data for the actual media. To trigger a media download, you will have to set up the builder by making this call: `${ADD_PARAM_MEDIA_EXAMPLE}`. -Methods supporting uploads can do so using up to ${len(PROTOCOL_TYPE_INFO)} different protocols: -${put_and(md_italic(PROTOCOL_TYPE_INFO.keys()))}. The distinctiveness of each is represented by customized +Methods supporting uploads can do so using up to ${len(PROTOCOL_TYPE_INFO)} different protocols: +${put_and(md_italic(PROTOCOL_TYPE_INFO.keys()))}. The distinctiveness of each is represented by customized `${api.terms.action}(...)` methods, which are then named ${put_and(enclose_in('`', ("%s(...)" % upload_action_fn(api.terms.upload_action, v['suffix']) for v in PROTOCOL_TYPE_INFO.values())))} respectively. ${'##'} Customization and Callbacks -You may alter the way an `${api.terms.action}()` method is called by providing a ${link('delegate', delegate_url)} to the -${link('Method Builder', call_builder_url)} before making the final `${api.terms.action}()` call. -Respective methods will be called to provide progress information, as well as determine whether the system should +You may alter the way an `${api.terms.action}()` method is called by providing a ${link('delegate', delegate_url)} to the +${link('Method Builder', call_builder_url)} before making the final `${api.terms.action}()` call. +Respective methods will be called to provide progress information, as well as determine whether the system should retry on failure. The ${link('delegate trait', delegate_url)} is default-implemented, allowing you to customize it with minimal effort. ${'##'} Optional Parts in Server-Requests -All structures provided by this library are made to be ${link('encodable', request_trait_url)} and -${link('decodable', response_trait_url)} via *json*. Optionals are used to indicate that partial requests are responses +All structures provided by this library are made to be ${link('encodable', request_trait_url)} and +${link('decodable', response_trait_url)} via *json*. Optionals are used to indicate that partial requests are responses are valid. -Most optionals are are considered ${link('Parts', part_trait_url)} which are identifiable by name, which will be sent to +Most optionals are are considered ${link('Parts', part_trait_url)} which are identifiable by name, which will be sent to the server to indicate either the set parts of the request or the desired parts in the response. ${'##'} Builder Arguments @@ -246,14 +246,14 @@ use std::default::Default; use ${util.library_name()}::{${hub_type}, oauth2, hyper, hyper_rustls, chrono, FieldMask}; % if comments: -// Get an ApplicationSecret instance by some means. It contains the `client_id` and +// Get an ApplicationSecret instance by some means. It contains the `client_id` and // `client_secret`, among other things. % endif let secret: oauth2::ApplicationSecret = Default::default(); % if comments: -// Instantiate the authenticator. It will choose a suitable authentication flow for you, +// Instantiate the authenticator. It will choose a suitable authentication flow for you, // unless you replace `None` with the desired Flow. -// Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about +// Provide your own `AuthenticatorDelegate` to adjust the way it operates and get feedback about // what's going on. You probably want to bring in your own `TokenStorage` to persist tokens and // retrieve them from storage. % endif @@ -268,7 +268,7 @@ let mut hub = ${hub_type}::new(hyper::Client::builder().build(hyper_rustls::Http ############################################################################################### ############################################################################################### <%def name="hub_usage_example(c, rust_doc=True, fr=None)">\ -<% +<% test_filter = rust_test_fn_invisible main_filter = rust_doc_test_norun if not rust_doc: @@ -312,7 +312,7 @@ ${self.test_hub(hub_type(c.schemas, util.canonical_name()))} ############################################################################################### <%def name="license()">\ # License -The **${util.library_name()}** library was generated by ${put_and(copyright.authors)}, and is placed +The **${util.library_name()}** library was generated by ${put_and(copyright.authors)}, and is placed under the *${copyright.license_abbrev}* license. You can read the full text at the repository's [license file][repo-license].