[INFO] crate gcp_client 0.1.4 is already in cache [INFO] checking gcp_client-0.1.4 against master#1557fb031b272b4c5bfcc7de5df7eddc7b36a584 for pr-73166 [INFO] extracting crate gcp_client 0.1.4 into /workspace/builds/worker-4/source [INFO] validating manifest of crates.io crate gcp_client 0.1.4 on toolchain 1557fb031b272b4c5bfcc7de5df7eddc7b36a584 [INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+1557fb031b272b4c5bfcc7de5df7eddc7b36a584" "read-manifest" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] started tweaking crates.io crate gcp_client 0.1.4 [INFO] finished tweaking crates.io crate gcp_client 0.1.4 [INFO] tweaked toml for crates.io crate gcp_client 0.1.4 written to /workspace/builds/worker-4/source/Cargo.toml [INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+1557fb031b272b4c5bfcc7de5df7eddc7b36a584" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update", kill_on_drop: false }` [INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+1557fb031b272b4c5bfcc7de5df7eddc7b36a584" "fetch" "--locked" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Blocking waiting for file lock on package cache [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "MAP_USER_ID=0" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--network" "none" "rustops/crates-build-env@sha256:d9fbb4e2287ab3795bdefaf705efb7541a8875c13bce71e067d6b01dc5ed759b" "/opt/rustwide/cargo-home/bin/cargo" "+1557fb031b272b4c5bfcc7de5df7eddc7b36a584" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap. [INFO] [stdout] cb8f111560255a9f27efe525ede24c702501f0e901a4a2b3ec69c0b923a03970 [INFO] running `Command { std: "docker" "start" "-a" "cb8f111560255a9f27efe525ede24c702501f0e901a4a2b3ec69c0b923a03970", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "cb8f111560255a9f27efe525ede24c702501f0e901a4a2b3ec69c0b923a03970", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "cb8f111560255a9f27efe525ede24c702501f0e901a4a2b3ec69c0b923a03970", kill_on_drop: false }` [INFO] [stdout] cb8f111560255a9f27efe525ede24c702501f0e901a4a2b3ec69c0b923a03970 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "MAP_USER_ID=0" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--network" "none" "rustops/crates-build-env@sha256:d9fbb4e2287ab3795bdefaf705efb7541a8875c13bce71e067d6b01dc5ed759b" "/opt/rustwide/cargo-home/bin/cargo" "+1557fb031b272b4c5bfcc7de5df7eddc7b36a584" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 39b416500264b60a5641eac3ed298cdb6e07a20490f3b79d68b31f9600b3006d [INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap. [INFO] running `Command { std: "docker" "start" "-a" "39b416500264b60a5641eac3ed298cdb6e07a20490f3b79d68b31f9600b3006d", kill_on_drop: false }` [INFO] [stderr] Compiling proc-macro2 v1.0.19 [INFO] [stderr] Compiling unicode-xid v0.2.1 [INFO] [stderr] Compiling libc v0.2.73 [INFO] [stderr] Compiling log v0.4.11 [INFO] [stderr] Checking futures-core v0.3.5 [INFO] [stderr] Compiling pin-project-internal v0.4.22 [INFO] [stderr] Checking fnv v1.0.7 [INFO] [stderr] Compiling memchr v2.3.3 [INFO] [stderr] Checking slab v0.4.2 [INFO] [stderr] Checking pin-project-lite v0.1.7 [INFO] [stderr] Checking tower-service v0.3.0 [INFO] [stderr] Checking pin-utils v0.1.0 [INFO] [stderr] Compiling anyhow v1.0.31 [INFO] [stderr] Checking itoa v0.4.6 [INFO] [stderr] Compiling either v1.5.3 [INFO] [stderr] Checking futures-sink v0.3.5 [INFO] [stderr] Compiling httparse v1.3.4 [INFO] [stderr] Compiling serde_derive v1.0.114 [INFO] [stderr] Checking percent-encoding v2.1.0 [INFO] [stderr] Checking base64 v0.11.0 [INFO] [stderr] Compiling hashbrown v0.8.1 [INFO] [stderr] Checking tracing-core v0.1.11 [INFO] [stderr] Compiling indexmap v1.5.0 [INFO] [stderr] Checking futures-channel v0.3.5 [INFO] [stderr] Compiling itertools v0.8.2 [INFO] [stderr] Checking http v0.2.1 [INFO] [stderr] Checking want v0.3.0 [INFO] [stderr] Compiling quote v1.0.7 [INFO] [stderr] Checking iovec v0.1.4 [INFO] [stderr] Checking net2 v0.2.34 [INFO] [stderr] Checking getrandom v0.1.14 [INFO] [stderr] Checking time v0.1.43 [INFO] [stderr] Checking socket2 v0.3.12 [INFO] [stderr] Compiling syn v1.0.35 [INFO] [stderr] Checking rand_core v0.5.1 [INFO] [stderr] Checking mio v0.6.22 [INFO] [stderr] Checking rand_pcg v0.2.1 [INFO] [stderr] Checking rand_chacha v0.2.2 [INFO] [stderr] Checking rand v0.7.3 [INFO] [stderr] Checking tokio v0.2.22 [INFO] [stderr] Checking http-body v0.3.1 [INFO] [stderr] Checking tokio-util v0.3.1 [INFO] [stderr] Checking tower-make v0.3.0 [INFO] [stderr] Compiling tracing-attributes v0.1.9 [INFO] [stderr] Compiling prost-derive v0.6.1 [INFO] [stderr] Compiling async-stream-impl v0.2.1 [INFO] [stderr] Compiling async-trait v0.1.36 [INFO] [stderr] Checking async-stream v0.2.1 [INFO] [stderr] Checking tracing v0.1.16 [INFO] [stderr] Checking pin-project v0.4.22 [INFO] [stderr] Checking futures-util v0.3.5 [INFO] [stderr] Checking tower-discover v0.3.0 [INFO] [stderr] Checking tower-retry v0.3.0 [INFO] [stderr] Checking tower-buffer v0.3.0 [INFO] [stderr] Checking tower-load-shed v0.3.0 [INFO] [stderr] Checking tower-timeout v0.3.0 [INFO] [stderr] Checking tracing-futures v0.2.4 [INFO] [stderr] Checking prost v0.6.1 [INFO] [stderr] Checking tower-load v0.3.0 [INFO] [stderr] Checking prost-types v0.6.1 [INFO] [stderr] Checking tower-limit v0.3.1 [INFO] [stderr] Checking h2 v0.2.6 [INFO] [stderr] Checking tower-ready-cache v0.3.1 [INFO] [stderr] Checking tower-util v0.3.1 [INFO] [stderr] Checking tower-balance v0.3.0 [INFO] [stderr] Checking serde v1.0.114 [INFO] [stderr] Checking tower v0.3.1 [INFO] [stderr] Checking hyper v0.13.7 [INFO] [stderr] Checking tonic v0.2.1 [INFO] [stderr] Checking gcp_client v0.1.4 (/opt/rustwide/workdir) [INFO] [stderr] error: could not compile `gcp_client`. [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] process didn't exit successfully: `rustc --crate-name gcp_client --edition=2018 src/mod.rs --error-format=json --json=diagnostic-rendered-ansi --crate-type lib --emit=dep-info,metadata -Cembed-bitcode=no -C debuginfo=2 -C metadata=7957fe9c7774a3ee -C extra-filename=-7957fe9c7774a3ee --out-dir /opt/rustwide/target/debug/deps -L dependency=/opt/rustwide/target/debug/deps --extern prost=/opt/rustwide/target/debug/deps/libprost-90cafa67b9b30d4b.rmeta --extern prost_types=/opt/rustwide/target/debug/deps/libprost_types-0cd27a586f5eb8c6.rmeta --extern serde=/opt/rustwide/target/debug/deps/libserde-87abc9b736c19128.rmeta --extern tonic=/opt/rustwide/target/debug/deps/libtonic-122a1e92ae29f862.rmeta --cap-lints=forbid` (signal: 9, SIGKILL: kill) [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/bigtable/v1.rs:774:6349 [INFO] [stdout] | [INFO] [stdout] 774 | # [ doc = r" Generated client implementations." ] pub mod bigtable_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service for reading from and writing to existing Bigtables." ] pub struct BigtableServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BigtableServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Streams back the contents of all requested rows, optionally applying" ] # [ doc = " the same Reader filter to each. Depending on their size, rows may be" ] # [ doc = " broken up across multiple responses, but atomicity of each row will still" ] # [ doc = " be preserved." ] pub async fn read_rows ( & mut self , request : impl tonic :: IntoRequest < super :: ReadRowsRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: ReadRowsResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v1.BigtableService/ReadRows" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a sample of row keys in the table. The returned row keys will" ] # [ doc = " delimit contiguous sections of the table of approximately equal size," ] # [ doc = " which can be used to break up the data for distributed tasks like" ] # [ doc = " mapreduces." ] pub async fn sample_row_keys ( & mut self , request : impl tonic :: IntoRequest < super :: SampleRowKeysRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: SampleRowKeysResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v1.BigtableService/SampleRowKeys" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mutates a row atomically. Cells already present in the row are left" ] # [ doc = " unchanged unless explicitly changed by 'mutation'." ] pub async fn mutate_row ( & mut self , request : impl tonic :: IntoRequest < super :: MutateRowRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v1.BigtableService/MutateRow" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mutates multiple rows in a batch. Each individual row is mutated" ] # [ doc = " atomically as in MutateRow, but the entire batch is not executed" ] # [ doc = " atomically." ] pub async fn mutate_rows ( & mut self , request : impl tonic :: IntoRequest < super :: MutateRowsRequest > , ) -> Result < tonic :: Response < super :: MutateRowsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v1.BigtableService/MutateRows" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mutates a row atomically based on the output of a predicate Reader filter." ] pub async fn check_and_mutate_row ( & mut self , request : impl tonic :: IntoRequest < super :: CheckAndMutateRowRequest > , ) -> Result < tonic :: Response < super :: CheckAndMutateRowResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v1.BigtableService/CheckAndMutateRow" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Modifies a row atomically, reading the latest existing timestamp/value from" ] # [ doc = " the specified columns and writing a new value at" ] # [ doc = " max(existing timestamp, current server time) based on pre-defined" ] # [ doc = " read/modify/write rules. Returns the new contents of all modified cells." ] pub async fn read_modify_write_row ( & mut self , request : impl tonic :: IntoRequest < super :: ReadModifyWriteRowRequest > , ) -> Result < tonic :: Response < super :: Row > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v1.BigtableService/ReadModifyWriteRow" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BigtableServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BigtableServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BigtableServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_imports)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/bigtable/admin/cluster/v1.rs:194:10998 [INFO] [stdout] | [INFO] [stdout] 194 | # [ doc = r" Generated client implementations." ] pub mod bigtable_cluster_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service for managing zonal Cloud Bigtable resources." ] pub struct BigtableClusterServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BigtableClusterServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists the supported zones for the given project." ] pub async fn list_zones ( & mut self , request : impl tonic :: IntoRequest < super :: ListZonesRequest > , ) -> Result < tonic :: Response < super :: ListZonesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListZones" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a particular cluster." ] pub async fn get_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: GetClusterRequest > , ) -> Result < tonic :: Response < super :: Cluster > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.cluster.v1.BigtableClusterService/GetCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all clusters in the given project, along with any zones for which" ] # [ doc = " cluster information could not be retrieved." ] pub async fn list_clusters ( & mut self , request : impl tonic :: IntoRequest < super :: ListClustersRequest > , ) -> Result < tonic :: Response < super :: ListClustersResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListClusters" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a cluster and begins preparing it to begin serving. The returned" ] # [ doc = " cluster embeds as its \"current_operation\" a long-running operation which" ] # [ doc = " can be used to track the progress of turning up the new cluster." ] # [ doc = " Immediately upon completion of this request:" ] # [ doc = " * The cluster will be readable via the API, with all requested attributes" ] # [ doc = " but no allocated resources." ] # [ doc = " Until completion of the embedded operation:" ] # [ doc = " * Cancelling the operation will render the cluster immediately unreadable" ] # [ doc = " via the API." ] # [ doc = " * All other attempts to modify or delete the cluster will be rejected." ] # [ doc = " Upon completion of the embedded operation:" ] # [ doc = " * Billing for all successfully-allocated resources will begin (some types" ] # [ doc = " may have lower than the requested levels)." ] # [ doc = " * New tables can be created in the cluster." ] # [ doc = " * The cluster's allocated resource levels will be readable via the API." ] # [ doc = " The embedded operation's \"metadata\" field type is" ] # [ doc = " [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata]" ] # [ doc = " The embedded operation's \"response\" field type is" ] # [ doc = " [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful." ] pub async fn create_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: CreateClusterRequest > , ) -> Result < tonic :: Response < super :: Cluster > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.cluster.v1.BigtableClusterService/CreateCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a cluster, and begins allocating or releasing resources as" ] # [ doc = " requested. The returned cluster embeds as its \"current_operation\" a" ] # [ doc = " long-running operation which can be used to track the progress of updating" ] # [ doc = " the cluster." ] # [ doc = " Immediately upon completion of this request:" ] # [ doc = " * For resource types where a decrease in the cluster's allocation has been" ] # [ doc = " requested, billing will be based on the newly-requested level." ] # [ doc = " Until completion of the embedded operation:" ] # [ doc = " * Cancelling the operation will set its metadata's \"cancelled_at_time\"," ] # [ doc = " and begin restoring resources to their pre-request values. The operation" ] # [ doc = " is guaranteed to succeed at undoing all resource changes, after which" ] # [ doc = " point it will terminate with a CANCELLED status." ] # [ doc = " * All other attempts to modify or delete the cluster will be rejected." ] # [ doc = " * Reading the cluster via the API will continue to give the pre-request" ] # [ doc = " resource levels." ] # [ doc = " Upon completion of the embedded operation:" ] # [ doc = " * Billing will begin for all successfully-allocated resources (some types" ] # [ doc = " may have lower than the requested levels)." ] # [ doc = " * All newly-reserved resources will be available for serving the cluster's" ] # [ doc = " tables." ] # [ doc = " * The cluster's new resource levels will be readable via the API." ] # [ doc = " [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata]" ] # [ doc = " The embedded operation's \"response\" field type is" ] # [ doc = " [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful." ] pub async fn update_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: Cluster > , ) -> Result < tonic :: Response < super :: Cluster > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.cluster.v1.BigtableClusterService/UpdateCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Marks a cluster and all of its tables for permanent deletion in 7 days." ] # [ doc = " Immediately upon completion of the request:" ] # [ doc = " * Billing will cease for all of the cluster's reserved resources." ] # [ doc = " * The cluster's \"delete_time\" field will be set 7 days in the future." ] # [ doc = " Soon afterward:" ] # [ doc = " * All tables within the cluster will become unavailable." ] # [ doc = " Prior to the cluster's \"delete_time\":" ] # [ doc = " * The cluster can be recovered with a call to UndeleteCluster." ] # [ doc = " * All other attempts to modify or delete the cluster will be rejected." ] # [ doc = " At the cluster's \"delete_time\":" ] # [ doc = " * The cluster and *all of its tables* will immediately and irrevocably" ] # [ doc = " disappear from the API, and their data will be permanently deleted." ] pub async fn delete_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteClusterRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.cluster.v1.BigtableClusterService/DeleteCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Cancels the scheduled deletion of an cluster and begins preparing it to" ] # [ doc = " resume serving. The returned operation will also be embedded as the" ] # [ doc = " cluster's \"current_operation\"." ] # [ doc = " Immediately upon completion of this request:" ] # [ doc = " * The cluster's \"delete_time\" field will be unset, protecting it from" ] # [ doc = " automatic deletion." ] # [ doc = " Until completion of the returned operation:" ] # [ doc = " * The operation cannot be cancelled." ] # [ doc = " Upon completion of the returned operation:" ] # [ doc = " * Billing for the cluster's resources will resume." ] # [ doc = " * All tables within the cluster will be available." ] # [ doc = " [UndeleteClusterMetadata][google.bigtable.admin.cluster.v1.UndeleteClusterMetadata]" ] # [ doc = " The embedded operation's \"response\" field type is" ] # [ doc = " [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful." ] pub async fn undelete_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: UndeleteClusterRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.cluster.v1.BigtableClusterService/UndeleteCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BigtableClusterServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BigtableClusterServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BigtableClusterServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/bigtable/admin/table/v1.rs:219:7889 [INFO] [stdout] | [INFO] [stdout] 219 | # [ doc = r" Generated client implementations." ] pub mod bigtable_table_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service for creating, configuring, and deleting Cloud Bigtable tables." ] # [ doc = " Provides access to the table schemas only, not the data stored within the" ] # [ doc = " tables." ] pub struct BigtableTableServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BigtableTableServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new table, to be served from a specified cluster." ] # [ doc = " The table can be created with a full set of initial column families," ] # [ doc = " specified in the request." ] pub async fn create_table ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTableRequest > , ) -> Result < tonic :: Response < super :: Table > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/CreateTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the names of all tables served from a specified cluster." ] pub async fn list_tables ( & mut self , request : impl tonic :: IntoRequest < super :: ListTablesRequest > , ) -> Result < tonic :: Response < super :: ListTablesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/ListTables" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the schema of the specified table, including its column families." ] pub async fn get_table ( & mut self , request : impl tonic :: IntoRequest < super :: GetTableRequest > , ) -> Result < tonic :: Response < super :: Table > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/GetTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently deletes a specified table and all of its data." ] pub async fn delete_table ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTableRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/DeleteTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Changes the name of a specified table." ] # [ doc = " Cannot be used to move tables between clusters, zones, or projects." ] pub async fn rename_table ( & mut self , request : impl tonic :: IntoRequest < super :: RenameTableRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/RenameTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new column family within a specified table." ] pub async fn create_column_family ( & mut self , request : impl tonic :: IntoRequest < super :: CreateColumnFamilyRequest > , ) -> Result < tonic :: Response < super :: ColumnFamily > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/CreateColumnFamily" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Changes the configuration of a specified column family." ] pub async fn update_column_family ( & mut self , request : impl tonic :: IntoRequest < super :: ColumnFamily > , ) -> Result < tonic :: Response < super :: ColumnFamily > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/UpdateColumnFamily" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently deletes a specified column family and all of its data." ] pub async fn delete_column_family ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteColumnFamilyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/DeleteColumnFamily" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Delete all rows in a table corresponding to a particular prefix" ] pub async fn bulk_delete_rows ( & mut self , request : impl tonic :: IntoRequest < super :: BulkDeleteRowsRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.table.v1.BigtableTableService/BulkDeleteRows" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BigtableTableServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BigtableTableServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BigtableTableServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/bigtable/admin/v2.rs:1459:21398 [INFO] [stdout] | [INFO] [stdout] 1459 | # [ doc = r" Generated client implementations." ] pub mod bigtable_table_admin_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service for creating, configuring, and deleting Cloud Bigtable tables." ] # [ doc = "" ] # [ doc = "" ] # [ doc = " Provides access to the table schemas only, not the data stored within" ] # [ doc = " the tables." ] pub struct BigtableTableAdminClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BigtableTableAdminClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new table in the specified instance." ] # [ doc = " The table can be created with a full set of initial column families," ] # [ doc = " specified in the request." ] pub async fn create_table ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTableRequest > , ) -> Result < tonic :: Response < super :: Table > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/CreateTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new table from the specified snapshot. The target table must" ] # [ doc = " not exist. The snapshot and the table must be in the same instance." ] # [ doc = "" ] # [ doc = " Note: This is a private alpha release of Cloud Bigtable snapshots. This" ] # [ doc = " feature is not currently available to most Cloud Bigtable customers. This" ] # [ doc = " feature might be changed in backward-incompatible ways and is not" ] # [ doc = " recommended for production use. It is not subject to any SLA or deprecation" ] # [ doc = " policy." ] pub async fn create_table_from_snapshot ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTableFromSnapshotRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/CreateTableFromSnapshot" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all tables served from a specified instance." ] pub async fn list_tables ( & mut self , request : impl tonic :: IntoRequest < super :: ListTablesRequest > , ) -> Result < tonic :: Response < super :: ListTablesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/ListTables" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets metadata information about the specified table." ] pub async fn get_table ( & mut self , request : impl tonic :: IntoRequest < super :: GetTableRequest > , ) -> Result < tonic :: Response < super :: Table > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/GetTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently deletes a specified table and all of its data." ] pub async fn delete_table ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTableRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/DeleteTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Performs a series of column family modifications on the specified table." ] # [ doc = " Either all or none of the modifications will occur before this method" ] # [ doc = " returns, but data requests received prior to that point may see a table" ] # [ doc = " where only some modifications have taken effect." ] pub async fn modify_column_families ( & mut self , request : impl tonic :: IntoRequest < super :: ModifyColumnFamiliesRequest > , ) -> Result < tonic :: Response < super :: Table > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/ModifyColumnFamilies" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently drop/delete a row range from a specified table. The request can" ] # [ doc = " specify whether to delete all rows in a table, or only those that match a" ] # [ doc = " particular prefix." ] pub async fn drop_row_range ( & mut self , request : impl tonic :: IntoRequest < super :: DropRowRangeRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/DropRowRange" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Generates a consistency token for a Table, which can be used in" ] # [ doc = " CheckConsistency to check whether mutations to the table that finished" ] # [ doc = " before this call started have been replicated. The tokens will be available" ] # [ doc = " for 90 days." ] pub async fn generate_consistency_token ( & mut self , request : impl tonic :: IntoRequest < super :: GenerateConsistencyTokenRequest > , ) -> Result < tonic :: Response < super :: GenerateConsistencyTokenResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/GenerateConsistencyToken" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Checks replication consistency based on a consistency token, that is, if" ] # [ doc = " replication has caught up based on the conditions specified in the token" ] # [ doc = " and the check request." ] pub async fn check_consistency ( & mut self , request : impl tonic :: IntoRequest < super :: CheckConsistencyRequest > , ) -> Result < tonic :: Response < super :: CheckConsistencyResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/CheckConsistency" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new snapshot in the specified cluster from the specified" ] # [ doc = " source table. The cluster and the table must be in the same instance." ] # [ doc = "" ] # [ doc = " Note: This is a private alpha release of Cloud Bigtable snapshots. This" ] # [ doc = " feature is not currently available to most Cloud Bigtable customers. This" ] # [ doc = " feature might be changed in backward-incompatible ways and is not" ] # [ doc = " recommended for production use. It is not subject to any SLA or deprecation" ] # [ doc = " policy." ] pub async fn snapshot_table ( & mut self , request : impl tonic :: IntoRequest < super :: SnapshotTableRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/SnapshotTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets metadata information about the specified snapshot." ] # [ doc = "" ] # [ doc = " Note: This is a private alpha release of Cloud Bigtable snapshots. This" ] # [ doc = " feature is not currently available to most Cloud Bigtable customers. This" ] # [ doc = " feature might be changed in backward-incompatible ways and is not" ] # [ doc = " recommended for production use. It is not subject to any SLA or deprecation" ] # [ doc = " policy." ] pub async fn get_snapshot ( & mut self , request : impl tonic :: IntoRequest < super :: GetSnapshotRequest > , ) -> Result < tonic :: Response < super :: Snapshot > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/GetSnapshot" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all snapshots associated with the specified cluster." ] # [ doc = "" ] # [ doc = " Note: This is a private alpha release of Cloud Bigtable snapshots. This" ] # [ doc = " feature is not currently available to most Cloud Bigtable customers. This" ] # [ doc = " feature might be changed in backward-incompatible ways and is not" ] # [ doc = " recommended for production use. It is not subject to any SLA or deprecation" ] # [ doc = " policy." ] pub async fn list_snapshots ( & mut self , request : impl tonic :: IntoRequest < super :: ListSnapshotsRequest > , ) -> Result < tonic :: Response < super :: ListSnapshotsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/ListSnapshots" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently deletes the specified snapshot." ] # [ doc = "" ] # [ doc = " Note: This is a private alpha release of Cloud Bigtable snapshots. This" ] # [ doc = " feature is not currently available to most Cloud Bigtable customers. This" ] # [ doc = " feature might be changed in backward-incompatible ways and is not" ] # [ doc = " recommended for production use. It is not subject to any SLA or deprecation" ] # [ doc = " policy." ] pub async fn delete_snapshot ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSnapshotRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/DeleteSnapshot" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Starts creating a new Cloud Bigtable Backup. The returned backup" ] # [ doc = " [long-running operation][google.longrunning.Operation] can be used to" ] # [ doc = " track creation of the backup. The" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type is" ] # [ doc = " [CreateBackupMetadata][google.bigtable.admin.v2.CreateBackupMetadata]. The" ] # [ doc = " [response][google.longrunning.Operation.response] field type is" ] # [ doc = " [Backup][google.bigtable.admin.v2.Backup], if successful. Cancelling the" ] # [ doc = " returned operation will stop the creation and delete the backup." ] pub async fn create_backup ( & mut self , request : impl tonic :: IntoRequest < super :: CreateBackupRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/CreateBackup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets metadata on a pending or completed Cloud Bigtable Backup." ] pub async fn get_backup ( & mut self , request : impl tonic :: IntoRequest < super :: GetBackupRequest > , ) -> Result < tonic :: Response < super :: Backup > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/GetBackup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a pending or completed Cloud Bigtable Backup." ] pub async fn update_backup ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateBackupRequest > , ) -> Result < tonic :: Response < super :: Backup > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/UpdateBackup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a pending or completed Cloud Bigtable backup." ] pub async fn delete_backup ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteBackupRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/DeleteBackup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists Cloud Bigtable backups. Returns both completed and pending" ] # [ doc = " backups." ] pub async fn list_backups ( & mut self , request : impl tonic :: IntoRequest < super :: ListBackupsRequest > , ) -> Result < tonic :: Response < super :: ListBackupsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/ListBackups" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create a new table by restoring from a completed backup. The new table" ] # [ doc = " must be in the same instance as the instance containing the backup. The" ] # [ doc = " returned table [long-running operation][google.longrunning.Operation] can" ] # [ doc = " be used to track the progress of the operation, and to cancel it. The" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type is" ] # [ doc = " [RestoreTableMetadata][google.bigtable.admin.RestoreTableMetadata]. The" ] # [ doc = " [response][google.longrunning.Operation.response] type is" ] # [ doc = " [Table][google.bigtable.admin.v2.Table], if successful." ] pub async fn restore_table ( & mut self , request : impl tonic :: IntoRequest < super :: RestoreTableRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/RestoreTable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a resource." ] # [ doc = " Returns an empty policy if the resource exists but does not have a policy" ] # [ doc = " set." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on a Table or Backup resource." ] # [ doc = " Replaces any existing policy." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that the caller has on the specified table resource." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.admin.v2.BigtableTableAdmin/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BigtableTableAdminClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BigtableTableAdminClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BigtableTableAdminClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/bigtable/v2.rs:884:6553 [INFO] [stdout] | [INFO] [stdout] 884 | # [ doc = r" Generated client implementations." ] pub mod bigtable_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service for reading from and writing to existing Bigtable tables." ] pub struct BigtableClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BigtableClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Streams back the contents of all requested rows in key order, optionally" ] # [ doc = " applying the same Reader filter to each. Depending on their size," ] # [ doc = " rows and cells may be broken up across multiple responses, but" ] # [ doc = " atomicity of each row will still be preserved. See the" ] # [ doc = " ReadRowsResponse documentation for details." ] pub async fn read_rows ( & mut self , request : impl tonic :: IntoRequest < super :: ReadRowsRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: ReadRowsResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v2.Bigtable/ReadRows" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a sample of row keys in the table. The returned row keys will" ] # [ doc = " delimit contiguous sections of the table of approximately equal size," ] # [ doc = " which can be used to break up the data for distributed tasks like" ] # [ doc = " mapreduces." ] pub async fn sample_row_keys ( & mut self , request : impl tonic :: IntoRequest < super :: SampleRowKeysRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: SampleRowKeysResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v2.Bigtable/SampleRowKeys" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mutates a row atomically. Cells already present in the row are left" ] # [ doc = " unchanged unless explicitly changed by `mutation`." ] pub async fn mutate_row ( & mut self , request : impl tonic :: IntoRequest < super :: MutateRowRequest > , ) -> Result < tonic :: Response < super :: MutateRowResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v2.Bigtable/MutateRow" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mutates multiple rows in a batch. Each individual row is mutated" ] # [ doc = " atomically as in MutateRow, but the entire batch is not executed" ] # [ doc = " atomically." ] pub async fn mutate_rows ( & mut self , request : impl tonic :: IntoRequest < super :: MutateRowsRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: MutateRowsResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v2.Bigtable/MutateRows" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mutates a row atomically based on the output of a predicate Reader filter." ] pub async fn check_and_mutate_row ( & mut self , request : impl tonic :: IntoRequest < super :: CheckAndMutateRowRequest > , ) -> Result < tonic :: Response < super :: CheckAndMutateRowResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v2.Bigtable/CheckAndMutateRow" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Modifies a row atomically on the server. The method reads the latest" ] # [ doc = " existing timestamp and value from the specified columns and writes a new" ] # [ doc = " entry based on pre-defined read/modify/write rules. The new value for the" ] # [ doc = " timestamp is the greater of the existing timestamp or the current server" ] # [ doc = " time. The method returns the new contents of all modified cells." ] pub async fn read_modify_write_row ( & mut self , request : impl tonic :: IntoRequest < super :: ReadModifyWriteRowRequest > , ) -> Result < tonic :: Response < super :: ReadModifyWriteRowResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.bigtable.v2.Bigtable/ReadModifyWriteRow" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BigtableClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BigtableClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BigtableClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/longrunning.rs:140:7753 [INFO] [stdout] | [INFO] [stdout] 140 | # [ doc = r" Generated client implementations." ] pub mod operations_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Manages long-running operations with an API service." ] # [ doc = "" ] # [ doc = " When an API method normally takes long time to complete, it can be designed" ] # [ doc = " to return [Operation][google.longrunning.Operation] to the client, and the client can use this" ] # [ doc = " interface to receive the real response asynchronously by polling the" ] # [ doc = " operation resource, or pass the operation resource to another API (such as" ] # [ doc = " Google Cloud Pub/Sub API) to receive the response. Any API service that" ] # [ doc = " returns long-running operations should implement the `Operations` interface" ] # [ doc = " so developers can have a consistent client experience." ] pub struct OperationsClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > OperationsClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists operations that match the specified filter in the request. If the" ] # [ doc = " server doesn't support this method, it returns `UNIMPLEMENTED`." ] # [ doc = "" ] # [ doc = " NOTE: the `name` binding allows API services to override the binding" ] # [ doc = " to use different resource name schemes, such as `users/*/operations`. To" ] # [ doc = " override the binding, API services can add a binding such as" ] # [ doc = " `\"/v1/{name=users/*}/operations\"` to their service configuration." ] # [ doc = " For backwards compatibility, the default name includes the operations" ] # [ doc = " collection id, however overriding users must ensure the name binding" ] # [ doc = " is the parent resource, without the operations collection id." ] pub async fn list_operations ( & mut self , request : impl tonic :: IntoRequest < super :: ListOperationsRequest > , ) -> Result < tonic :: Response < super :: ListOperationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.longrunning.Operations/ListOperations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the latest state of a long-running operation. Clients can use this" ] # [ doc = " method to poll the operation result at intervals as recommended by the API" ] # [ doc = " service." ] pub async fn get_operation ( & mut self , request : impl tonic :: IntoRequest < super :: GetOperationRequest > , ) -> Result < tonic :: Response < super :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.longrunning.Operations/GetOperation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a long-running operation. This method indicates that the client is" ] # [ doc = " no longer interested in the operation result. It does not cancel the" ] # [ doc = " operation. If the server doesn't support this method, it returns" ] # [ doc = " `google.rpc.Code.UNIMPLEMENTED`." ] pub async fn delete_operation ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteOperationRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.longrunning.Operations/DeleteOperation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Starts asynchronous cancellation on a long-running operation. The server" ] # [ doc = " makes a best effort to cancel the operation, but success is not" ] # [ doc = " guaranteed. If the server doesn't support this method, it returns" ] # [ doc = " `google.rpc.Code.UNIMPLEMENTED`. Clients can use" ] # [ doc = " [Operations.GetOperation][google.longrunning.Operations.GetOperation] or" ] # [ doc = " other methods to check whether the cancellation succeeded or whether the" ] # [ doc = " operation completed despite cancellation. On successful cancellation," ] # [ doc = " the operation is not deleted; instead, it becomes an operation with" ] # [ doc = " an [Operation.error][google.longrunning.Operation.error] value with a [google.rpc.Status.code][google.rpc.Status.code] of 1," ] # [ doc = " corresponding to `Code.CANCELLED`." ] pub async fn cancel_operation ( & mut self , request : impl tonic :: IntoRequest < super :: CancelOperationRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.longrunning.Operations/CancelOperation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Waits for the specified long-running operation until it is done or reaches" ] # [ doc = " at most a specified timeout, returning the latest state. If the operation" ] # [ doc = " is already done, the latest state is immediately returned. If the timeout" ] # [ doc = " specified is greater than the default HTTP/RPC timeout, the HTTP/RPC" ] # [ doc = " timeout is used. If the server does not support this method, it returns" ] # [ doc = " `google.rpc.Code.UNIMPLEMENTED`." ] # [ doc = " Note that this method is on a best-effort basis. It may return the latest" ] # [ doc = " state before the specified timeout (including immediately), meaning even an" ] # [ doc = " immediate response is no guarantee that the operation is done." ] pub async fn wait_operation ( & mut self , request : impl tonic :: IntoRequest < super :: WaitOperationRequest > , ) -> Result < tonic :: Response < super :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.longrunning.Operations/WaitOperation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for OperationsClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for OperationsClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "OperationsClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/appengine/v1.rs:1222:16 [INFO] [stdout] | [INFO] [stdout] 1222 | use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/storage/v1.rs:2584:44673 [INFO] [stdout] | [INFO] [stdout] 2584 | # [ doc = r" Generated client implementations." ] pub mod storage_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Manages Google Cloud Storage resources." ] pub struct StorageClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > StorageClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Permanently deletes the ACL entry for the specified entity on the specified" ] # [ doc = " bucket." ] pub async fn delete_bucket_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteBucketAccessControlRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/DeleteBucketAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the ACL entry for the specified entity on the specified bucket." ] pub async fn get_bucket_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: GetBucketAccessControlRequest > , ) -> Result < tonic :: Response < super :: BucketAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetBucketAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new ACL entry on the specified bucket." ] pub async fn insert_bucket_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: InsertBucketAccessControlRequest > , ) -> Result < tonic :: Response < super :: BucketAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/InsertBucketAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves ACL entries on the specified bucket." ] pub async fn list_bucket_access_controls ( & mut self , request : impl tonic :: IntoRequest < super :: ListBucketAccessControlsRequest > , ) -> Result < tonic :: Response < super :: ListBucketAccessControlsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ListBucketAccessControls" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an ACL entry on the specified bucket. Equivalent to" ] # [ doc = " PatchBucketAccessControl, but all unspecified fields will be" ] # [ doc = " reset to their default values." ] pub async fn update_bucket_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateBucketAccessControlRequest > , ) -> Result < tonic :: Response < super :: BucketAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/UpdateBucketAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an ACL entry on the specified bucket." ] pub async fn patch_bucket_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: PatchBucketAccessControlRequest > , ) -> Result < tonic :: Response < super :: BucketAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/PatchBucketAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently deletes an empty bucket." ] pub async fn delete_bucket ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteBucketRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/DeleteBucket" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns metadata for the specified bucket." ] pub async fn get_bucket ( & mut self , request : impl tonic :: IntoRequest < super :: GetBucketRequest > , ) -> Result < tonic :: Response < super :: Bucket > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetBucket" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new bucket." ] pub async fn insert_bucket ( & mut self , request : impl tonic :: IntoRequest < super :: InsertBucketRequest > , ) -> Result < tonic :: Response < super :: Bucket > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/InsertBucket" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List active object change notification channels for this bucket." ] pub async fn list_channels ( & mut self , request : impl tonic :: IntoRequest < super :: ListChannelsRequest > , ) -> Result < tonic :: Response < super :: ListChannelsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ListChannels" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves a list of buckets for a given project." ] pub async fn list_buckets ( & mut self , request : impl tonic :: IntoRequest < super :: ListBucketsRequest > , ) -> Result < tonic :: Response < super :: ListBucketsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ListBuckets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Locks retention policy on a bucket." ] pub async fn lock_bucket_retention_policy ( & mut self , request : impl tonic :: IntoRequest < super :: LockRetentionPolicyRequest > , ) -> Result < tonic :: Response < super :: Bucket > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/LockBucketRetentionPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the IAM policy for the specified bucket." ] pub async fn get_bucket_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetBucketIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an IAM policy for the specified bucket." ] pub async fn set_bucket_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/SetBucketIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Tests a set of permissions on the given bucket to see which, if" ] # [ doc = " any, are held by the caller." ] pub async fn test_bucket_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/TestBucketIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a bucket. Changes to the bucket will be readable immediately after" ] # [ doc = " writing, but configuration changes may take time to propagate." ] pub async fn patch_bucket ( & mut self , request : impl tonic :: IntoRequest < super :: PatchBucketRequest > , ) -> Result < tonic :: Response < super :: Bucket > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/PatchBucket" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a bucket. Equivalent to PatchBucket, but always replaces all" ] # [ doc = " mutatable fields of the bucket with new values, reverting all" ] # [ doc = " unspecified fields to their default values." ] # [ doc = " Like PatchBucket, Changes to the bucket will be readable immediately after" ] # [ doc = " writing, but configuration changes may take time to propagate." ] pub async fn update_bucket ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateBucketRequest > , ) -> Result < tonic :: Response < super :: Bucket > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/UpdateBucket" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Halts \"Object Change Notification\" push messagages." ] # [ doc = " See https://cloud.google.com/storage/docs/object-change-notification" ] # [ doc = " Note: this is not related to the newer \"Notifications\" resource, which" ] # [ doc = " are stopped using DeleteNotification." ] pub async fn stop_channel ( & mut self , request : impl tonic :: IntoRequest < super :: StopChannelRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/StopChannel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently deletes the default object ACL entry for the specified entity" ] # [ doc = " on the specified bucket." ] pub async fn delete_default_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteDefaultObjectAccessControlRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/DeleteDefaultObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the default object ACL entry for the specified entity on the" ] # [ doc = " specified bucket." ] pub async fn get_default_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: GetDefaultObjectAccessControlRequest > , ) -> Result < tonic :: Response < super :: ObjectAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetDefaultObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new default object ACL entry on the specified bucket." ] pub async fn insert_default_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: InsertDefaultObjectAccessControlRequest > , ) -> Result < tonic :: Response < super :: ObjectAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/InsertDefaultObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves default object ACL entries on the specified bucket." ] pub async fn list_default_object_access_controls ( & mut self , request : impl tonic :: IntoRequest < super :: ListDefaultObjectAccessControlsRequest > , ) -> Result < tonic :: Response < super :: ListObjectAccessControlsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ListDefaultObjectAccessControls" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a default object ACL entry on the specified bucket." ] pub async fn patch_default_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: PatchDefaultObjectAccessControlRequest > , ) -> Result < tonic :: Response < super :: ObjectAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/PatchDefaultObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a default object ACL entry on the specified bucket. Equivalent to" ] # [ doc = " PatchDefaultObjectAccessControl, but modifies all unspecified fields to" ] # [ doc = " their default values." ] pub async fn update_default_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateDefaultObjectAccessControlRequest > , ) -> Result < tonic :: Response < super :: ObjectAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/UpdateDefaultObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently deletes a notification subscription." ] # [ doc = " Note: Older, \"Object Change Notification\" push subscriptions should be" ] # [ doc = " deleted using StopChannel instead." ] pub async fn delete_notification ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteNotificationRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/DeleteNotification" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " View a notification configuration." ] pub async fn get_notification ( & mut self , request : impl tonic :: IntoRequest < super :: GetNotificationRequest > , ) -> Result < tonic :: Response < super :: Notification > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetNotification" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a notification subscription for a given bucket." ] # [ doc = " These notifications, when triggered, publish messages to the specified" ] # [ doc = " Cloud Pub/Sub topics." ] # [ doc = " See https://cloud.google.com/storage/docs/pubsub-notifications." ] pub async fn insert_notification ( & mut self , request : impl tonic :: IntoRequest < super :: InsertNotificationRequest > , ) -> Result < tonic :: Response < super :: Notification > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/InsertNotification" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves a list of notification subscriptions for a given bucket." ] pub async fn list_notifications ( & mut self , request : impl tonic :: IntoRequest < super :: ListNotificationsRequest > , ) -> Result < tonic :: Response < super :: ListNotificationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ListNotifications" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Permanently deletes the ACL entry for the specified entity on the specified" ] # [ doc = " object." ] pub async fn delete_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteObjectAccessControlRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/DeleteObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the ACL entry for the specified entity on the specified object." ] pub async fn get_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: GetObjectAccessControlRequest > , ) -> Result < tonic :: Response < super :: ObjectAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new ACL entry on the specified object." ] pub async fn insert_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: InsertObjectAccessControlRequest > , ) -> Result < tonic :: Response < super :: ObjectAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/InsertObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves ACL entries on the specified object." ] pub async fn list_object_access_controls ( & mut self , request : impl tonic :: IntoRequest < super :: ListObjectAccessControlsRequest > , ) -> Result < tonic :: Response < super :: ListObjectAccessControlsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ListObjectAccessControls" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Patches an ACL entry on the specified object. Patch is similar to update," ] # [ doc = " but only applies or appends the specified fields in the" ] # [ doc = " object_access_control object. Other fields are unaffected." ] pub async fn patch_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: PatchObjectAccessControlRequest > , ) -> Result < tonic :: Response < super :: ObjectAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/PatchObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an ACL entry on the specified object." ] pub async fn update_object_access_control ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateObjectAccessControlRequest > , ) -> Result < tonic :: Response < super :: ObjectAccessControl > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/UpdateObjectAccessControl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Concatenates a list of existing objects into a new object in the same" ] # [ doc = " bucket." ] pub async fn compose_object ( & mut self , request : impl tonic :: IntoRequest < super :: ComposeObjectRequest > , ) -> Result < tonic :: Response < super :: Object > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ComposeObject" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Copies a source object to a destination object. Optionally overrides" ] # [ doc = " metadata." ] pub async fn copy_object ( & mut self , request : impl tonic :: IntoRequest < super :: CopyObjectRequest > , ) -> Result < tonic :: Response < super :: Object > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/CopyObject" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an object and its metadata. Deletions are permanent if versioning" ] # [ doc = " is not enabled for the bucket, or if the `generation` parameter" ] # [ doc = " is used." ] pub async fn delete_object ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteObjectRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/DeleteObject" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves an object's metadata." ] pub async fn get_object ( & mut self , request : impl tonic :: IntoRequest < super :: GetObjectRequest > , ) -> Result < tonic :: Response < super :: Object > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetObject" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Reads an object's data." ] pub async fn get_object_media ( & mut self , request : impl tonic :: IntoRequest < super :: GetObjectMediaRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: GetObjectMediaResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetObjectMedia" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Stores a new object and metadata." ] # [ doc = "" ] # [ doc = " An object can be written either in a single message stream or in a" ] # [ doc = " resumable sequence of message streams. To write using a single stream," ] # [ doc = " the client should include in the first message of the stream an" ] # [ doc = " `InsertObjectSpec` describing the destination bucket, object, and any" ] # [ doc = " preconditions. Additionally, the final message must set 'finish_write' to" ] # [ doc = " true, or else it is an error." ] # [ doc = "" ] # [ doc = " For a resumable write, the client should instead call" ] # [ doc = " `StartResumableWrite()` and provide that method an `InsertObjectSpec.`" ] # [ doc = " They should then attach the returned `upload_id` to the first message of" ] # [ doc = " each following call to `Insert`. If there is an error or the connection is" ] # [ doc = " broken during the resumable `Insert()`, the client should check the status" ] # [ doc = " of the `Insert()` by calling `QueryWriteStatus()` and continue writing from" ] # [ doc = " the returned `committed_size`. This may be less than the amount of data the" ] # [ doc = " client previously sent." ] # [ doc = "" ] # [ doc = " The service will not view the object as complete until the client has" ] # [ doc = " sent an `Insert` with `finish_write` set to `true`. Sending any" ] # [ doc = " requests on a stream after sending a request with `finish_write` set to" ] # [ doc = " `true` will cause an error. The client **should** check the" ] # [ doc = " `Object` it receives to determine how much data the service was" ] # [ doc = " able to commit and whether the service views the object as complete." ] pub async fn insert_object ( & mut self , request : impl tonic :: IntoStreamingRequest < Message = super :: InsertObjectRequest > ) -> Result < tonic :: Response < super :: Object > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/InsertObject" ) ; self . inner . client_streaming ( request . into_streaming_request ( ) , path , codec ) . await } # [ doc = " Retrieves a list of objects matching the criteria." ] pub async fn list_objects ( & mut self , request : impl tonic :: IntoRequest < super :: ListObjectsRequest > , ) -> Result < tonic :: Response < super :: ListObjectsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ListObjects" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Rewrites a source object to a destination object. Optionally overrides" ] # [ doc = " metadata." ] pub async fn rewrite_object ( & mut self , request : impl tonic :: IntoRequest < super :: RewriteObjectRequest > , ) -> Result < tonic :: Response < super :: RewriteResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/RewriteObject" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Starts a resumable write. How long the write operation remains valid, and" ] # [ doc = " what happens when the write operation becomes invalid, are" ] # [ doc = " service-dependent." ] pub async fn start_resumable_write ( & mut self , request : impl tonic :: IntoRequest < super :: StartResumableWriteRequest > , ) -> Result < tonic :: Response < super :: StartResumableWriteResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/StartResumableWrite" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Determines the `committed_size` for an object that is being written, which" ] # [ doc = " can then be used as the `write_offset` for the next `Write()` call." ] # [ doc = "" ] # [ doc = " If the object does not exist (i.e., the object has been deleted, or the" ] # [ doc = " first `Write()` has not yet reached the service), this method returns the" ] # [ doc = " error `NOT_FOUND`." ] # [ doc = "" ] # [ doc = " The client **may** call `QueryWriteStatus()` at any time to determine how" ] # [ doc = " much data has been processed for this object. This is useful if the" ] # [ doc = " client is buffering data and needs to know which data can be safely" ] # [ doc = " evicted. For any sequence of `QueryWriteStatus()` calls for a given" ] # [ doc = " object name, the sequence of returned `committed_size` values will be" ] # [ doc = " non-decreasing." ] pub async fn query_write_status ( & mut self , request : impl tonic :: IntoRequest < super :: QueryWriteStatusRequest > , ) -> Result < tonic :: Response < super :: QueryWriteStatusResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/QueryWriteStatus" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an object's metadata." ] pub async fn patch_object ( & mut self , request : impl tonic :: IntoRequest < super :: PatchObjectRequest > , ) -> Result < tonic :: Response < super :: Object > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/PatchObject" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an object's metadata. Equivalent to PatchObject, but always" ] # [ doc = " replaces all mutatable fields of the bucket with new values, reverting all" ] # [ doc = " unspecified fields to their default values." ] pub async fn update_object ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateObjectRequest > , ) -> Result < tonic :: Response < super :: Object > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/UpdateObject" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the IAM policy for the specified object." ] pub async fn get_object_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetObjectIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an IAM policy for the specified object." ] pub async fn set_object_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/SetObjectIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Tests a set of permissions on the given object to see which, if" ] # [ doc = " any, are held by the caller." ] pub async fn test_object_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/TestObjectIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Watch for changes on all objects in a bucket." ] pub async fn watch_all_objects ( & mut self , request : impl tonic :: IntoRequest < super :: WatchAllObjectsRequest > , ) -> Result < tonic :: Response < super :: Channel > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/WatchAllObjects" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves the name of a project's Google Cloud Storage service account." ] pub async fn get_service_account ( & mut self , request : impl tonic :: IntoRequest < super :: GetProjectServiceAccountRequest > , ) -> Result < tonic :: Response < super :: ServiceAccount > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetServiceAccount" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new HMAC key for the given service account." ] pub async fn create_hmac_key ( & mut self , request : impl tonic :: IntoRequest < super :: CreateHmacKeyRequest > , ) -> Result < tonic :: Response < super :: CreateHmacKeyResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/CreateHmacKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a given HMAC key. Key must be in an INACTIVE state." ] pub async fn delete_hmac_key ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteHmacKeyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/DeleteHmacKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an existing HMAC key metadata for the given id." ] pub async fn get_hmac_key ( & mut self , request : impl tonic :: IntoRequest < super :: GetHmacKeyRequest > , ) -> Result < tonic :: Response < super :: HmacKeyMetadata > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/GetHmacKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists HMAC keys under a given project with the additional filters provided." ] pub async fn list_hmac_keys ( & mut self , request : impl tonic :: IntoRequest < super :: ListHmacKeysRequest > , ) -> Result < tonic :: Response < super :: ListHmacKeysResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/ListHmacKeys" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a given HMAC key state between ACTIVE and INACTIVE." ] pub async fn update_hmac_key ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateHmacKeyRequest > , ) -> Result < tonic :: Response < super :: HmacKeyMetadata > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.storage.v1.Storage/UpdateHmacKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for StorageClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for StorageClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "StorageClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/datastore/v1.rs:859:6370 [INFO] [stdout] | [INFO] [stdout] 859 | # [ doc = r" Generated client implementations." ] pub mod datastore_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Each RPC normalizes the partition IDs of the keys in its input entities," ] # [ doc = " and always returns entities with keys with normalized partition IDs." ] # [ doc = " This applies to all keys and entities, including those in values, except keys" ] # [ doc = " with both an empty path and an empty or unset partition ID. Normalization of" ] # [ doc = " input keys sets the project ID (if not already set) to the project ID from" ] # [ doc = " the request." ] # [ doc = "" ] pub struct DatastoreClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DatastoreClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Looks up entities by key." ] pub async fn lookup ( & mut self , request : impl tonic :: IntoRequest < super :: LookupRequest > , ) -> Result < tonic :: Response < super :: LookupResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1.Datastore/Lookup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Queries for entities." ] pub async fn run_query ( & mut self , request : impl tonic :: IntoRequest < super :: RunQueryRequest > , ) -> Result < tonic :: Response < super :: RunQueryResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1.Datastore/RunQuery" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Begins a new transaction." ] pub async fn begin_transaction ( & mut self , request : impl tonic :: IntoRequest < super :: BeginTransactionRequest > , ) -> Result < tonic :: Response < super :: BeginTransactionResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1.Datastore/BeginTransaction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Commits a transaction, optionally creating, deleting or modifying some" ] # [ doc = " entities." ] pub async fn commit ( & mut self , request : impl tonic :: IntoRequest < super :: CommitRequest > , ) -> Result < tonic :: Response < super :: CommitResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1.Datastore/Commit" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Rolls back a transaction." ] pub async fn rollback ( & mut self , request : impl tonic :: IntoRequest < super :: RollbackRequest > , ) -> Result < tonic :: Response < super :: RollbackResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1.Datastore/Rollback" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Allocates IDs for the given keys, which is useful for referencing an entity" ] # [ doc = " before it is inserted." ] pub async fn allocate_ids ( & mut self , request : impl tonic :: IntoRequest < super :: AllocateIdsRequest > , ) -> Result < tonic :: Response < super :: AllocateIdsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1.Datastore/AllocateIds" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Prevents the supplied keys' IDs from being auto-allocated by Cloud" ] # [ doc = " Datastore." ] pub async fn reserve_ids ( & mut self , request : impl tonic :: IntoRequest < super :: ReserveIdsRequest > , ) -> Result < tonic :: Response < super :: ReserveIdsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1.Datastore/ReserveIds" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DatastoreClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DatastoreClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DatastoreClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/datastore/admin/v1.rs:366:8203 [INFO] [stdout] | [INFO] [stdout] 366 | # [ doc = r" Generated client implementations." ] pub mod datastore_admin_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Google Cloud Datastore Admin API" ] # [ doc = "" ] # [ doc = "" ] # [ doc = " The Datastore Admin API provides several admin services for Cloud Datastore." ] # [ doc = "" ] # [ doc = " -----------------------------------------------------------------------------" ] # [ doc = " ## Concepts" ] # [ doc = "" ] # [ doc = " Project, namespace, kind, and entity as defined in the Google Cloud Datastore" ] # [ doc = " API." ] # [ doc = "" ] # [ doc = " Operation: An Operation represents work being performed in the background." ] # [ doc = "" ] # [ doc = " EntityFilter: Allows specifying a subset of entities in a project. This is" ] # [ doc = " specified as a combination of kinds and namespaces (either or both of which" ] # [ doc = " may be all)." ] # [ doc = "" ] # [ doc = " -----------------------------------------------------------------------------" ] # [ doc = " ## Services" ] # [ doc = "" ] # [ doc = " # Export/Import" ] # [ doc = "" ] # [ doc = " The Export/Import service provides the ability to copy all or a subset of" ] # [ doc = " entities to/from Google Cloud Storage." ] # [ doc = "" ] # [ doc = " Exported data may be imported into Cloud Datastore for any Google Cloud" ] # [ doc = " Platform project. It is not restricted to the export source project. It is" ] # [ doc = " possible to export from one project and then import into another." ] # [ doc = "" ] # [ doc = " Exported data can also be loaded into Google BigQuery for analysis." ] # [ doc = "" ] # [ doc = " Exports and imports are performed asynchronously. An Operation resource is" ] # [ doc = " created for each export/import. The state (including any errors encountered)" ] # [ doc = " of the export/import may be queried via the Operation resource." ] # [ doc = "" ] # [ doc = " # Index" ] # [ doc = "" ] # [ doc = " The index service manages Cloud Datastore composite indexes." ] # [ doc = "" ] # [ doc = " Index creation and deletion are performed asynchronously." ] # [ doc = " An Operation resource is created for each such asynchronous operation." ] # [ doc = " The state of the operation (including any errors encountered)" ] # [ doc = " may be queried via the Operation resource." ] # [ doc = "" ] # [ doc = " # Operation" ] # [ doc = "" ] # [ doc = " The Operations collection provides a record of actions performed for the" ] # [ doc = " specified project (including any operations in progress). Operations are not" ] # [ doc = " created directly but through calls on other collections or resources." ] # [ doc = "" ] # [ doc = " An operation that is not yet done may be cancelled. The request to cancel is" ] # [ doc = " asynchronous and the operation may continue to run for some time after the" ] # [ doc = " request to cancel is made." ] # [ doc = "" ] # [ doc = " An operation that is done may be deleted so that it is no longer listed as" ] # [ doc = " part of the Operation collection." ] # [ doc = "" ] # [ doc = " ListOperations returns all pending operations, but not completed operations." ] # [ doc = "" ] # [ doc = " Operations are created by service DatastoreAdmin," ] # [ doc = " but are accessed via service google.longrunning.Operations." ] pub struct DatastoreAdminClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DatastoreAdminClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Exports a copy of all or a subset of entities from Google Cloud Datastore" ] # [ doc = " to another storage system, such as Google Cloud Storage. Recent updates to" ] # [ doc = " entities may not be reflected in the export. The export occurs in the" ] # [ doc = " background and its progress can be monitored and managed via the" ] # [ doc = " Operation resource that is created. The output of an export may only be" ] # [ doc = " used once the associated operation is done. If an export operation is" ] # [ doc = " cancelled before completion it may leave partial data behind in Google" ] # [ doc = " Cloud Storage." ] pub async fn export_entities ( & mut self , request : impl tonic :: IntoRequest < super :: ExportEntitiesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.admin.v1.DatastoreAdmin/ExportEntities" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Imports entities into Google Cloud Datastore. Existing entities with the" ] # [ doc = " same key are overwritten. The import occurs in the background and its" ] # [ doc = " progress can be monitored and managed via the Operation resource that is" ] # [ doc = " created. If an ImportEntities operation is cancelled, it is possible" ] # [ doc = " that a subset of the data has already been imported to Cloud Datastore." ] pub async fn import_entities ( & mut self , request : impl tonic :: IntoRequest < super :: ImportEntitiesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.admin.v1.DatastoreAdmin/ImportEntities" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an index." ] pub async fn get_index ( & mut self , request : impl tonic :: IntoRequest < super :: GetIndexRequest > , ) -> Result < tonic :: Response < super :: Index > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.admin.v1.DatastoreAdmin/GetIndex" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the indexes that match the specified filters. Datastore uses an" ] # [ doc = " eventually consistent query to fetch the list of indexes and may" ] # [ doc = " occasionally return stale results." ] pub async fn list_indexes ( & mut self , request : impl tonic :: IntoRequest < super :: ListIndexesRequest > , ) -> Result < tonic :: Response < super :: ListIndexesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.admin.v1.DatastoreAdmin/ListIndexes" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DatastoreAdminClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DatastoreAdminClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DatastoreAdminClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/datastore/admin/v1beta1.rs:226:6297 [INFO] [stdout] | [INFO] [stdout] 226 | # [ doc = r" Generated client implementations." ] pub mod datastore_admin_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Google Cloud Datastore Admin API" ] # [ doc = "" ] # [ doc = " The Datastore Admin API provides several admin services for Cloud Datastore." ] # [ doc = "" ] # [ doc = " -----------------------------------------------------------------------------" ] # [ doc = " ## Concepts" ] # [ doc = "" ] # [ doc = " Project, namespace, kind, and entity as defined in the Google Cloud Datastore" ] # [ doc = " API." ] # [ doc = "" ] # [ doc = " Operation: An Operation represents work being performed in the background." ] # [ doc = "" ] # [ doc = " EntityFilter: Allows specifying a subset of entities in a project. This is" ] # [ doc = " specified as a combination of kinds and namespaces (either or both of which" ] # [ doc = " may be all)." ] # [ doc = "" ] # [ doc = " -----------------------------------------------------------------------------" ] # [ doc = " ## Services" ] # [ doc = "" ] # [ doc = " # Export/Import" ] # [ doc = "" ] # [ doc = " The Export/Import service provides the ability to copy all or a subset of" ] # [ doc = " entities to/from Google Cloud Storage." ] # [ doc = "" ] # [ doc = " Exported data may be imported into Cloud Datastore for any Google Cloud" ] # [ doc = " Platform project. It is not restricted to the export source project. It is" ] # [ doc = " possible to export from one project and then import into another." ] # [ doc = "" ] # [ doc = " Exported data can also be loaded into Google BigQuery for analysis." ] # [ doc = "" ] # [ doc = " Exports and imports are performed asynchronously. An Operation resource is" ] # [ doc = " created for each export/import. The state (including any errors encountered)" ] # [ doc = " of the export/import may be queried via the Operation resource." ] # [ doc = "" ] # [ doc = " # Operation" ] # [ doc = "" ] # [ doc = " The Operations collection provides a record of actions performed for the" ] # [ doc = " specified project (including any operations in progress). Operations are not" ] # [ doc = " created directly but through calls on other collections or resources." ] # [ doc = "" ] # [ doc = " An operation that is not yet done may be cancelled. The request to cancel is" ] # [ doc = " asynchronous and the operation may continue to run for some time after the" ] # [ doc = " request to cancel is made." ] # [ doc = "" ] # [ doc = " An operation that is done may be deleted so that it is no longer listed as" ] # [ doc = " part of the Operation collection." ] # [ doc = "" ] # [ doc = " ListOperations returns all pending operations, but not completed operations." ] # [ doc = "" ] # [ doc = " Operations are created by service DatastoreAdmin," ] # [ doc = " but are accessed via service google.longrunning.Operations." ] pub struct DatastoreAdminClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DatastoreAdminClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Exports a copy of all or a subset of entities from Google Cloud Datastore" ] # [ doc = " to another storage system, such as Google Cloud Storage. Recent updates to" ] # [ doc = " entities may not be reflected in the export. The export occurs in the" ] # [ doc = " background and its progress can be monitored and managed via the" ] # [ doc = " Operation resource that is created. The output of an export may only be" ] # [ doc = " used once the associated operation is done. If an export operation is" ] # [ doc = " cancelled before completion it may leave partial data behind in Google" ] # [ doc = " Cloud Storage." ] pub async fn export_entities ( & mut self , request : impl tonic :: IntoRequest < super :: ExportEntitiesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.admin.v1beta1.DatastoreAdmin/ExportEntities" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Imports entities into Google Cloud Datastore. Existing entities with the" ] # [ doc = " same key are overwritten. The import occurs in the background and its" ] # [ doc = " progress can be monitored and managed via the Operation resource that is" ] # [ doc = " created. If an ImportEntities operation is cancelled, it is possible" ] # [ doc = " that a subset of the data has already been imported to Cloud Datastore." ] pub async fn import_entities ( & mut self , request : impl tonic :: IntoRequest < super :: ImportEntitiesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.admin.v1beta1.DatastoreAdmin/ImportEntities" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DatastoreAdminClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DatastoreAdminClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DatastoreAdminClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/datastore/v1beta3.rs:876:6405 [INFO] [stdout] | [INFO] [stdout] 876 | # [ doc = r" Generated client implementations." ] pub mod datastore_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Each RPC normalizes the partition IDs of the keys in its input entities," ] # [ doc = " and always returns entities with keys with normalized partition IDs." ] # [ doc = " This applies to all keys and entities, including those in values, except keys" ] # [ doc = " with both an empty path and an empty or unset partition ID. Normalization of" ] # [ doc = " input keys sets the project ID (if not already set) to the project ID from" ] # [ doc = " the request." ] # [ doc = "" ] pub struct DatastoreClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DatastoreClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Looks up entities by key." ] pub async fn lookup ( & mut self , request : impl tonic :: IntoRequest < super :: LookupRequest > , ) -> Result < tonic :: Response < super :: LookupResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1beta3.Datastore/Lookup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Queries for entities." ] pub async fn run_query ( & mut self , request : impl tonic :: IntoRequest < super :: RunQueryRequest > , ) -> Result < tonic :: Response < super :: RunQueryResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1beta3.Datastore/RunQuery" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Begins a new transaction." ] pub async fn begin_transaction ( & mut self , request : impl tonic :: IntoRequest < super :: BeginTransactionRequest > , ) -> Result < tonic :: Response < super :: BeginTransactionResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1beta3.Datastore/BeginTransaction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Commits a transaction, optionally creating, deleting or modifying some" ] # [ doc = " entities." ] pub async fn commit ( & mut self , request : impl tonic :: IntoRequest < super :: CommitRequest > , ) -> Result < tonic :: Response < super :: CommitResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1beta3.Datastore/Commit" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Rolls back a transaction." ] pub async fn rollback ( & mut self , request : impl tonic :: IntoRequest < super :: RollbackRequest > , ) -> Result < tonic :: Response < super :: RollbackResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1beta3.Datastore/Rollback" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Allocates IDs for the given keys, which is useful for referencing an entity" ] # [ doc = " before it is inserted." ] pub async fn allocate_ids ( & mut self , request : impl tonic :: IntoRequest < super :: AllocateIdsRequest > , ) -> Result < tonic :: Response < super :: AllocateIdsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1beta3.Datastore/AllocateIds" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Prevents the supplied keys' IDs from being auto-allocated by Cloud" ] # [ doc = " Datastore." ] pub async fn reserve_ids ( & mut self , request : impl tonic :: IntoRequest < super :: ReserveIdsRequest > , ) -> Result < tonic :: Response < super :: ReserveIdsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.datastore.v1beta3.Datastore/ReserveIds" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DatastoreClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DatastoreClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DatastoreClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/iam/v1/mod.rs:282:5017 [INFO] [stdout] | [INFO] [stdout] 282 | # [ doc = r" Generated client implementations." ] pub mod iam_policy_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " ## API Overview" ] # [ doc = "" ] # [ doc = " Manages Identity and Access Management (IAM) policies." ] # [ doc = "" ] # [ doc = " Any implementation of an API that offers access control features" ] # [ doc = " implements the google.iam.v1.IAMPolicy interface." ] # [ doc = "" ] # [ doc = " ## Data model" ] # [ doc = "" ] # [ doc = " Access control is applied when a principal (user or service account), takes" ] # [ doc = " some action on a resource exposed by a service. Resources, identified by" ] # [ doc = " URI-like names, are the unit of access control specification. Service" ] # [ doc = " implementations can choose the granularity of access control and the" ] # [ doc = " supported permissions for their resources." ] # [ doc = " For example one database service may allow access control to be" ] # [ doc = " specified only at the Table level, whereas another might allow access control" ] # [ doc = " to also be specified at the Column level." ] # [ doc = "" ] # [ doc = " ## Policy Structure" ] # [ doc = "" ] # [ doc = " See google.iam.v1.Policy" ] # [ doc = "" ] # [ doc = " This is intentionally not a CRUD style API because access control policies" ] # [ doc = " are created and deleted implicitly with the resources to which they are" ] # [ doc = " attached." ] pub struct IamPolicyClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > IamPolicyClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Sets the access control policy on the specified resource. Replaces any" ] # [ doc = " existing policy." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.v1.IAMPolicy/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a resource." ] # [ doc = " Returns an empty policy if the resource exists and does not have a policy" ] # [ doc = " set." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.v1.IAMPolicy/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has on the specified resource." ] # [ doc = " If the resource does not exist, this will return an empty set of" ] # [ doc = " permissions, not a NOT_FOUND error." ] # [ doc = "" ] # [ doc = " Note: This operation is designed to be used for building permission-aware" ] # [ doc = " UIs and command-line tools, not for authorization checking. This operation" ] # [ doc = " may \"fail open\" without warning." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.v1.IAMPolicy/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for IamPolicyClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for IamPolicyClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "IamPolicyClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/iam/admin/v1.rs:742:20267 [INFO] [stdout] | [INFO] [stdout] 742 | # [ doc = r" Generated client implementations." ] pub mod iam_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Creates and manages service account objects." ] # [ doc = "" ] # [ doc = " Service account is an account that belongs to your project instead" ] # [ doc = " of to an individual end user. It is used to authenticate calls" ] # [ doc = " to a Google API." ] # [ doc = "" ] # [ doc = " To create a service account, specify the `project_id` and `account_id`" ] # [ doc = " for the account. The `account_id` is unique within the project, and used" ] # [ doc = " to generate the service account email address and a stable" ] # [ doc = " `unique_id`." ] # [ doc = "" ] # [ doc = " All other methods can identify accounts using the format" ] # [ doc = " `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`." ] # [ doc = " Using `-` as a wildcard for the `PROJECT_ID` will infer the project from" ] # [ doc = " the account. The `ACCOUNT` value can be the `email` address or the" ] # [ doc = " `unique_id` of the service account." ] pub struct IamClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > IamClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists [ServiceAccounts][google.iam.admin.v1.ServiceAccount] for a project." ] pub async fn list_service_accounts ( & mut self , request : impl tonic :: IntoRequest < super :: ListServiceAccountsRequest > , ) -> Result < tonic :: Response < super :: ListServiceAccountsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/ListServiceAccounts" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a [ServiceAccount][google.iam.admin.v1.ServiceAccount]." ] pub async fn get_service_account ( & mut self , request : impl tonic :: IntoRequest < super :: GetServiceAccountRequest > , ) -> Result < tonic :: Response < super :: ServiceAccount > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/GetServiceAccount" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a [ServiceAccount][google.iam.admin.v1.ServiceAccount]" ] # [ doc = " and returns it." ] pub async fn create_service_account ( & mut self , request : impl tonic :: IntoRequest < super :: CreateServiceAccountRequest > , ) -> Result < tonic :: Response < super :: ServiceAccount > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/CreateServiceAccount" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a [ServiceAccount][google.iam.admin.v1.ServiceAccount]." ] # [ doc = "" ] # [ doc = " Currently, only the following fields are updatable:" ] # [ doc = " `display_name` and `description`." ] pub async fn update_service_account ( & mut self , request : impl tonic :: IntoRequest < super :: ServiceAccount > , ) -> Result < tonic :: Response < super :: ServiceAccount > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/UpdateServiceAccount" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a [ServiceAccount][google.iam.admin.v1.ServiceAccount]." ] pub async fn delete_service_account ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteServiceAccountRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/DeleteServiceAccount" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists [ServiceAccountKeys][google.iam.admin.v1.ServiceAccountKey]." ] pub async fn list_service_account_keys ( & mut self , request : impl tonic :: IntoRequest < super :: ListServiceAccountKeysRequest > , ) -> Result < tonic :: Response < super :: ListServiceAccountKeysResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/ListServiceAccountKeys" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the [ServiceAccountKey][google.iam.admin.v1.ServiceAccountKey]" ] # [ doc = " by key id." ] pub async fn get_service_account_key ( & mut self , request : impl tonic :: IntoRequest < super :: GetServiceAccountKeyRequest > , ) -> Result < tonic :: Response < super :: ServiceAccountKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/GetServiceAccountKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a [ServiceAccountKey][google.iam.admin.v1.ServiceAccountKey]" ] # [ doc = " and returns it." ] pub async fn create_service_account_key ( & mut self , request : impl tonic :: IntoRequest < super :: CreateServiceAccountKeyRequest > , ) -> Result < tonic :: Response < super :: ServiceAccountKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/CreateServiceAccountKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a [ServiceAccountKey][google.iam.admin.v1.ServiceAccountKey]." ] pub async fn delete_service_account_key ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteServiceAccountKeyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/DeleteServiceAccountKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signs a blob using a service account's system-managed private key." ] pub async fn sign_blob ( & mut self , request : impl tonic :: IntoRequest < super :: SignBlobRequest > , ) -> Result < tonic :: Response < super :: SignBlobResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/SignBlob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signs a JWT using a service account's system-managed private key." ] # [ doc = "" ] # [ doc = " If no expiry time (`exp`) is provided in the `SignJwtRequest`, IAM sets an" ] # [ doc = " an expiry time of one hour by default. If you request an expiry time of" ] # [ doc = " more than one hour, the request will fail." ] pub async fn sign_jwt ( & mut self , request : impl tonic :: IntoRequest < super :: SignJwtRequest > , ) -> Result < tonic :: Response < super :: SignJwtResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/SignJwt" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the Cloud IAM access control policy for a" ] # [ doc = " [ServiceAccount][google.iam.admin.v1.ServiceAccount]." ] # [ doc = "" ] # [ doc = " Note: Service accounts are both" ] # [ doc = " [resources and" ] # [ doc = " identities](/iam/docs/service-accounts#service_account_permissions). This" ] # [ doc = " method treats the service account as a resource. It returns the Cloud IAM" ] # [ doc = " policy that reflects what members have access to the service account." ] # [ doc = "" ] # [ doc = " This method does not return what resources the service account has access" ] # [ doc = " to. To see if a service account has access to a resource, call the" ] # [ doc = " `getIamPolicy` method on the target resource. For example, to view grants" ] # [ doc = " for a project, call the" ] # [ doc = " [projects.getIamPolicy](/resource-manager/reference/rest/v1/projects/getIamPolicy)" ] # [ doc = " method." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the Cloud IAM access control policy for a" ] # [ doc = " [ServiceAccount][google.iam.admin.v1.ServiceAccount]." ] # [ doc = "" ] # [ doc = " Note: Service accounts are both" ] # [ doc = " [resources and" ] # [ doc = " identities](/iam/docs/service-accounts#service_account_permissions). This" ] # [ doc = " method treats the service account as a resource. Use it to grant members" ] # [ doc = " access to the service account, such as when they need to impersonate it." ] # [ doc = "" ] # [ doc = " This method does not grant the service account access to other resources," ] # [ doc = " such as projects. To grant a service account access to resources, include" ] # [ doc = " the service account in the Cloud IAM policy for the desired resource, then" ] # [ doc = " call the appropriate `setIamPolicy` method on the target resource. For" ] # [ doc = " example, to grant a service account access to a project, call the" ] # [ doc = " [projects.setIamPolicy](/resource-manager/reference/rest/v1/projects/setIamPolicy)" ] # [ doc = " method." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Tests the specified permissions against the IAM access control policy" ] # [ doc = " for a [ServiceAccount][google.iam.admin.v1.ServiceAccount]." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Queries roles that can be granted on a particular resource." ] # [ doc = " A role is grantable if it can be used as the role in a binding for a policy" ] # [ doc = " for that resource." ] pub async fn query_grantable_roles ( & mut self , request : impl tonic :: IntoRequest < super :: QueryGrantableRolesRequest > , ) -> Result < tonic :: Response < super :: QueryGrantableRolesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/QueryGrantableRoles" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the Roles defined on a resource." ] pub async fn list_roles ( & mut self , request : impl tonic :: IntoRequest < super :: ListRolesRequest > , ) -> Result < tonic :: Response < super :: ListRolesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/ListRoles" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a Role definition." ] pub async fn get_role ( & mut self , request : impl tonic :: IntoRequest < super :: GetRoleRequest > , ) -> Result < tonic :: Response < super :: Role > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/GetRole" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new Role." ] pub async fn create_role ( & mut self , request : impl tonic :: IntoRequest < super :: CreateRoleRequest > , ) -> Result < tonic :: Response < super :: Role > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/CreateRole" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a Role definition." ] pub async fn update_role ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateRoleRequest > , ) -> Result < tonic :: Response < super :: Role > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/UpdateRole" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Soft deletes a role. The role is suspended and cannot be used to create new" ] # [ doc = " IAM Policy Bindings." ] # [ doc = " The Role will not be included in `ListRoles()` unless `show_deleted` is set" ] # [ doc = " in the `ListRolesRequest`. The Role contains the deleted boolean set." ] # [ doc = " Existing Bindings remains, but are inactive. The Role can be undeleted" ] # [ doc = " within 7 days. After 7 days the Role is deleted and all Bindings associated" ] # [ doc = " with the role are removed." ] pub async fn delete_role ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteRoleRequest > , ) -> Result < tonic :: Response < super :: Role > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/DeleteRole" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Undelete a Role, bringing it back in its previous state." ] pub async fn undelete_role ( & mut self , request : impl tonic :: IntoRequest < super :: UndeleteRoleRequest > , ) -> Result < tonic :: Response < super :: Role > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/UndeleteRole" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the permissions testable on a resource." ] # [ doc = " A permission is testable if it can be tested for an identity on a resource." ] pub async fn query_testable_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: QueryTestablePermissionsRequest > , ) -> Result < tonic :: Response < super :: QueryTestablePermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.admin.v1.IAM/QueryTestablePermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for IamClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for IamClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "IamClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/iam/credentials/v1.rs:145:4646 [INFO] [stdout] | [INFO] [stdout] 145 | # [ doc = r" Generated client implementations." ] pub mod iam_credentials_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " A service account is a special type of Google account that belongs to your" ] # [ doc = " application or a virtual machine (VM), instead of to an individual end user." ] # [ doc = " Your application assumes the identity of the service account to call Google" ] # [ doc = " APIs, so that the users aren't directly involved." ] # [ doc = "" ] # [ doc = " Service account credentials are used to temporarily assume the identity" ] # [ doc = " of the service account. Supported credential types include OAuth 2.0 access" ] # [ doc = " tokens, OpenID Connect ID tokens, self-signed JSON Web Tokens (JWTs), and" ] # [ doc = " more." ] pub struct IamCredentialsClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > IamCredentialsClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Generates an OAuth 2.0 access token for a service account." ] pub async fn generate_access_token ( & mut self , request : impl tonic :: IntoRequest < super :: GenerateAccessTokenRequest > , ) -> Result < tonic :: Response < super :: GenerateAccessTokenResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.credentials.v1.IAMCredentials/GenerateAccessToken" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Generates an OpenID Connect ID token for a service account." ] pub async fn generate_id_token ( & mut self , request : impl tonic :: IntoRequest < super :: GenerateIdTokenRequest > , ) -> Result < tonic :: Response < super :: GenerateIdTokenResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.credentials.v1.IAMCredentials/GenerateIdToken" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signs a blob using a service account's system-managed private key." ] pub async fn sign_blob ( & mut self , request : impl tonic :: IntoRequest < super :: SignBlobRequest > , ) -> Result < tonic :: Response < super :: SignBlobResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.credentials.v1.IAMCredentials/SignBlob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signs a JWT using a service account's system-managed private key." ] pub async fn sign_jwt ( & mut self , request : impl tonic :: IntoRequest < super :: SignJwtRequest > , ) -> Result < tonic :: Response < super :: SignJwtResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.iam.credentials.v1.IAMCredentials/SignJwt" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for IamCredentialsClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for IamCredentialsClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "IamCredentialsClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/resourcemanager/v2.rs:229:15981 [INFO] [stdout] | [INFO] [stdout] 229 | # [ doc = r" Generated client implementations." ] pub mod folders_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Manages Cloud Resource Folders." ] # [ doc = " Cloud Resource Folders can be used to organize the resources under an" ] # [ doc = " organization and to control the IAM policies applied to groups of resources." ] pub struct FoldersClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > FoldersClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists the Folders that are direct descendants of supplied parent resource." ] # [ doc = " List provides a strongly consistent view of the Folders underneath" ] # [ doc = " the specified parent resource." ] # [ doc = " List returns Folders sorted based upon the (ascending) lexical ordering" ] # [ doc = " of their display_name." ] # [ doc = " The caller must have `resourcemanager.folders.list` permission on the" ] # [ doc = " identified parent." ] pub async fn list_folders ( & mut self , request : impl tonic :: IntoRequest < super :: ListFoldersRequest > , ) -> Result < tonic :: Response < super :: ListFoldersResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/ListFolders" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Search for folders that match specific filter criteria." ] # [ doc = " Search provides an eventually consistent view of the folders a user has" ] # [ doc = " access to which meet the specified filter criteria." ] # [ doc = "" ] # [ doc = " This will only return folders on which the caller has the" ] # [ doc = " permission `resourcemanager.folders.get`." ] pub async fn search_folders ( & mut self , request : impl tonic :: IntoRequest < super :: SearchFoldersRequest > , ) -> Result < tonic :: Response < super :: SearchFoldersResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/SearchFolders" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves a Folder identified by the supplied resource name." ] # [ doc = " Valid Folder resource names have the format `folders/{folder_id}`" ] # [ doc = " (for example, `folders/1234`)." ] # [ doc = " The caller must have `resourcemanager.folders.get` permission on the" ] # [ doc = " identified folder." ] pub async fn get_folder ( & mut self , request : impl tonic :: IntoRequest < super :: GetFolderRequest > , ) -> Result < tonic :: Response < super :: Folder > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/GetFolder" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a Folder in the resource hierarchy." ] # [ doc = " Returns an Operation which can be used to track the progress of the" ] # [ doc = " folder creation workflow." ] # [ doc = " Upon success the Operation.response field will be populated with the" ] # [ doc = " created Folder." ] # [ doc = "" ] # [ doc = " In order to succeed, the addition of this new Folder must not violate" ] # [ doc = " the Folder naming, height or fanout constraints." ] # [ doc = "" ] # [ doc = " + The Folder's display_name must be distinct from all other Folder's that" ] # [ doc = " share its parent." ] # [ doc = " + The addition of the Folder must not cause the active Folder hierarchy" ] # [ doc = " to exceed a height of 4. Note, the full active + deleted Folder hierarchy" ] # [ doc = " is allowed to reach a height of 8; this provides additional headroom when" ] # [ doc = " moving folders that contain deleted folders." ] # [ doc = " + The addition of the Folder must not cause the total number of Folders" ] # [ doc = " under its parent to exceed 100." ] # [ doc = "" ] # [ doc = " If the operation fails due to a folder constraint violation, some errors" ] # [ doc = " may be returned by the CreateFolder request, with status code" ] # [ doc = " FAILED_PRECONDITION and an error description. Other folder constraint" ] # [ doc = " violations will be communicated in the Operation, with the specific" ] # [ doc = " PreconditionFailure returned via the details list in the Operation.error" ] # [ doc = " field." ] # [ doc = "" ] # [ doc = " The caller must have `resourcemanager.folders.create` permission on the" ] # [ doc = " identified parent." ] pub async fn create_folder ( & mut self , request : impl tonic :: IntoRequest < super :: CreateFolderRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/CreateFolder" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a Folder, changing its display_name." ] # [ doc = " Changes to the folder display_name will be rejected if they violate either" ] # [ doc = " the display_name formatting rules or naming constraints described in" ] # [ doc = " the [CreateFolder][google.cloud.resourcemanager.v2.Folders.CreateFolder] documentation." ] # [ doc = "" ] # [ doc = " The Folder's display name must start and end with a letter or digit," ] # [ doc = " may contain letters, digits, spaces, hyphens and underscores and can be" ] # [ doc = " no longer than 30 characters. This is captured by the regular expression:" ] # [ doc = " [\\p{L}\\p{N}]([\\p{L}\\p{N}_- ]{0,28}[\\p{L}\\p{N}])?." ] # [ doc = " The caller must have `resourcemanager.folders.update` permission on the" ] # [ doc = " identified folder." ] # [ doc = "" ] # [ doc = " If the update fails due to the unique name constraint then a" ] # [ doc = " PreconditionFailure explaining this violation will be returned" ] # [ doc = " in the Status.details field." ] pub async fn update_folder ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateFolderRequest > , ) -> Result < tonic :: Response < super :: Folder > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/UpdateFolder" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Moves a Folder under a new resource parent." ] # [ doc = " Returns an Operation which can be used to track the progress of the" ] # [ doc = " folder move workflow." ] # [ doc = " Upon success the Operation.response field will be populated with the" ] # [ doc = " moved Folder." ] # [ doc = " Upon failure, a FolderOperationError categorizing the failure cause will" ] # [ doc = " be returned - if the failure occurs synchronously then the" ] # [ doc = " FolderOperationError will be returned via the Status.details field" ] # [ doc = " and if it occurs asynchronously then the FolderOperation will be returned" ] # [ doc = " via the Operation.error field." ] # [ doc = " In addition, the Operation.metadata field will be populated with a" ] # [ doc = " FolderOperation message as an aid to stateless clients." ] # [ doc = " Folder moves will be rejected if they violate either the naming, height" ] # [ doc = " or fanout constraints described in the" ] # [ doc = " [CreateFolder][google.cloud.resourcemanager.v2.Folders.CreateFolder] documentation." ] # [ doc = " The caller must have `resourcemanager.folders.move` permission on the" ] # [ doc = " folder's current and proposed new parent." ] pub async fn move_folder ( & mut self , request : impl tonic :: IntoRequest < super :: MoveFolderRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/MoveFolder" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Requests deletion of a Folder. The Folder is moved into the" ] # [ doc = " [DELETE_REQUESTED][google.cloud.resourcemanager.v2.Folder.LifecycleState.DELETE_REQUESTED] state" ] # [ doc = " immediately, and is deleted approximately 30 days later. This method may" ] # [ doc = " only be called on an empty Folder in the" ] # [ doc = " [ACTIVE][google.cloud.resourcemanager.v2.Folder.LifecycleState.ACTIVE] state, where a Folder is empty if" ] # [ doc = " it doesn't contain any Folders or Projects in the" ] # [ doc = " [ACTIVE][google.cloud.resourcemanager.v2.Folder.LifecycleState.ACTIVE] state." ] # [ doc = " The caller must have `resourcemanager.folders.delete` permission on the" ] # [ doc = " identified folder." ] pub async fn delete_folder ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteFolderRequest > , ) -> Result < tonic :: Response < super :: Folder > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/DeleteFolder" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Cancels the deletion request for a Folder. This method may only be" ] # [ doc = " called on a Folder in the" ] # [ doc = " [DELETE_REQUESTED][google.cloud.resourcemanager.v2.Folder.LifecycleState.DELETE_REQUESTED] state." ] # [ doc = " In order to succeed, the Folder's parent must be in the" ] # [ doc = " [ACTIVE][google.cloud.resourcemanager.v2.Folder.LifecycleState.ACTIVE] state." ] # [ doc = " In addition, reintroducing the folder into the tree must not violate" ] # [ doc = " folder naming, height and fanout constraints described in the" ] # [ doc = " [CreateFolder][google.cloud.resourcemanager.v2.Folders.CreateFolder] documentation." ] # [ doc = " The caller must have `resourcemanager.folders.undelete` permission on the" ] # [ doc = " identified folder." ] pub async fn undelete_folder ( & mut self , request : impl tonic :: IntoRequest < super :: UndeleteFolderRequest > , ) -> Result < tonic :: Response < super :: Folder > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/UndeleteFolder" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a Folder. The returned policy may be" ] # [ doc = " empty if no such policy or resource exists. The `resource` field should" ] # [ doc = " be the Folder's resource name, e.g. \"folders/1234\"." ] # [ doc = " The caller must have `resourcemanager.folders.getIamPolicy` permission" ] # [ doc = " on the identified folder." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on a Folder, replacing any existing policy." ] # [ doc = " The `resource` field should be the Folder's resource name, e.g." ] # [ doc = " \"folders/1234\"." ] # [ doc = " The caller must have `resourcemanager.folders.setIamPolicy` permission" ] # [ doc = " on the identified folder." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has on the specified Folder." ] # [ doc = " The `resource` field should be the Folder's resource name," ] # [ doc = " e.g. \"folders/1234\"." ] # [ doc = "" ] # [ doc = " There are no permissions required for making this API call." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.resourcemanager.v2.Folders/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for FoldersClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for FoldersClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "FoldersClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/webrisk/v1.rs:280:5575 [INFO] [stdout] | [INFO] [stdout] 280 | # [ doc = r" Generated client implementations." ] pub mod web_risk_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Web Risk API defines an interface to detect malicious URLs on your" ] # [ doc = " website and in client applications." ] pub struct WebRiskServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > WebRiskServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Gets the most recent threat list diffs. These diffs should be applied to" ] # [ doc = " a local database of hashes to keep it up-to-date. If the local database is" ] # [ doc = " empty or excessively out-of-date, a complete snapshot of the database will" ] # [ doc = " be returned. This Method only updates a single ThreatList at a time. To" ] # [ doc = " update multiple ThreatList databases, this method needs to be called once" ] # [ doc = " for each list." ] pub async fn compute_threat_list_diff ( & mut self , request : impl tonic :: IntoRequest < super :: ComputeThreatListDiffRequest > , ) -> Result < tonic :: Response < super :: ComputeThreatListDiffResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.webrisk.v1.WebRiskService/ComputeThreatListDiff" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " This method is used to check whether a URI is on a given threatList." ] # [ doc = " Multiple threatLists may be searched in a single query." ] # [ doc = " The response will list all requested threatLists the URI was found to" ] # [ doc = " match. If the URI is not found on any of the requested ThreatList an" ] # [ doc = " empty response will be returned." ] pub async fn search_uris ( & mut self , request : impl tonic :: IntoRequest < super :: SearchUrisRequest > , ) -> Result < tonic :: Response < super :: SearchUrisResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.webrisk.v1.WebRiskService/SearchUris" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the full hashes that match the requested hash prefix." ] # [ doc = " This is used after a hash prefix is looked up in a threatList" ] # [ doc = " and there is a match. The client side threatList only holds partial hashes" ] # [ doc = " so the client must query this method to determine if there is a full" ] # [ doc = " hash match of a threat." ] pub async fn search_hashes ( & mut self , request : impl tonic :: IntoRequest < super :: SearchHashesRequest > , ) -> Result < tonic :: Response < super :: SearchHashesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.webrisk.v1.WebRiskService/SearchHashes" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a Submission of a URI suspected of containing phishing content to" ] # [ doc = " be reviewed. If the result verifies the existence of malicious phishing" ] # [ doc = " content, the site will be added to the [Google's Social Engineering" ] # [ doc = " lists](https://support.google.com/webmasters/answer/6350487/) in order to" ] # [ doc = " protect users that could get exposed to this threat in the future. Only" ] # [ doc = " projects with CREATE_SUBMISSION_USERS visibility can use this method." ] pub async fn create_submission ( & mut self , request : impl tonic :: IntoRequest < super :: CreateSubmissionRequest > , ) -> Result < tonic :: Response < super :: Submission > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.webrisk.v1.WebRiskService/CreateSubmission" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for WebRiskServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for WebRiskServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "WebRiskServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/webrisk/v1beta1.rs:256:3812 [INFO] [stdout] | [INFO] [stdout] 256 | # [ doc = r" Generated client implementations." ] pub mod web_risk_service_v1_beta1_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Web Risk v1beta1 API defines an interface to detect malicious URLs on your" ] # [ doc = " website and in client applications." ] pub struct WebRiskServiceV1Beta1Client < T > { inner : tonic :: client :: Grpc < T > , } impl < T > WebRiskServiceV1Beta1Client < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Gets the most recent threat list diffs." ] pub async fn compute_threat_list_diff ( & mut self , request : impl tonic :: IntoRequest < super :: ComputeThreatListDiffRequest > , ) -> Result < tonic :: Response < super :: ComputeThreatListDiffResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.webrisk.v1beta1.WebRiskServiceV1Beta1/ComputeThreatListDiff" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " This method is used to check whether a URI is on a given threatList." ] pub async fn search_uris ( & mut self , request : impl tonic :: IntoRequest < super :: SearchUrisRequest > , ) -> Result < tonic :: Response < super :: SearchUrisResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.webrisk.v1beta1.WebRiskServiceV1Beta1/SearchUris" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the full hashes that match the requested hash prefix." ] # [ doc = " This is used after a hash prefix is looked up in a threatList" ] # [ doc = " and there is a match. The client side threatList only holds partial hashes" ] # [ doc = " so the client must query this method to determine if there is a full" ] # [ doc = " hash match of a threat." ] pub async fn search_hashes ( & mut self , request : impl tonic :: IntoRequest < super :: SearchHashesRequest > , ) -> Result < tonic :: Response < super :: SearchHashesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.webrisk.v1beta1.WebRiskServiceV1Beta1/SearchHashes" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for WebRiskServiceV1Beta1Client < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for WebRiskServiceV1Beta1Client < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "WebRiskServiceV1Beta1Client {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/binaryauthorization/v1beta1.rs:375:8527 [INFO] [stdout] | [INFO] [stdout] 375 | # [ doc = r" Generated client implementations." ] pub mod binauthz_management_service_v1_beta1_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Google Cloud Management Service for Binary Authorization admission policies" ] # [ doc = " and attestation authorities." ] # [ doc = "" ] # [ doc = " This API implements a REST model with the following objects:" ] # [ doc = "" ] # [ doc = " * [Policy][google.cloud.binaryauthorization.v1beta1.Policy]" ] # [ doc = " * [Attestor][google.cloud.binaryauthorization.v1beta1.Attestor]" ] pub struct BinauthzManagementServiceV1Beta1Client < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BinauthzManagementServiceV1Beta1Client < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " A [policy][google.cloud.binaryauthorization.v1beta1.Policy] specifies the [attestors][google.cloud.binaryauthorization.v1beta1.Attestor] that must attest to" ] # [ doc = " a container image, before the project is allowed to deploy that" ] # [ doc = " image. There is at most one policy per project. All image admission" ] # [ doc = " requests are permitted if a project has no policy." ] # [ doc = "" ] # [ doc = " Gets the [policy][google.cloud.binaryauthorization.v1beta1.Policy] for this project. Returns a default" ] # [ doc = " [policy][google.cloud.binaryauthorization.v1beta1.Policy] if the project does not have one." ] pub async fn get_policy ( & mut self , request : impl tonic :: IntoRequest < super :: GetPolicyRequest > , ) -> Result < tonic :: Response < super :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.binaryauthorization.v1beta1.BinauthzManagementServiceV1Beta1/GetPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates or updates a project's [policy][google.cloud.binaryauthorization.v1beta1.Policy], and returns a copy of the" ] # [ doc = " new [policy][google.cloud.binaryauthorization.v1beta1.Policy]. A policy is always updated as a whole, to avoid race" ] # [ doc = " conditions with concurrent policy enforcement (or management!)" ] # [ doc = " requests. Returns NOT_FOUND if the project does not exist, INVALID_ARGUMENT" ] # [ doc = " if the request is malformed." ] pub async fn update_policy ( & mut self , request : impl tonic :: IntoRequest < super :: UpdatePolicyRequest > , ) -> Result < tonic :: Response < super :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.binaryauthorization.v1beta1.BinauthzManagementServiceV1Beta1/UpdatePolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates an [attestor][google.cloud.binaryauthorization.v1beta1.Attestor], and returns a copy of the new" ] # [ doc = " [attestor][google.cloud.binaryauthorization.v1beta1.Attestor]. Returns NOT_FOUND if the project does not exist," ] # [ doc = " INVALID_ARGUMENT if the request is malformed, ALREADY_EXISTS if the" ] # [ doc = " [attestor][google.cloud.binaryauthorization.v1beta1.Attestor] already exists." ] pub async fn create_attestor ( & mut self , request : impl tonic :: IntoRequest < super :: CreateAttestorRequest > , ) -> Result < tonic :: Response < super :: Attestor > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.binaryauthorization.v1beta1.BinauthzManagementServiceV1Beta1/CreateAttestor" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an [attestor][google.cloud.binaryauthorization.v1beta1.Attestor]." ] # [ doc = " Returns NOT_FOUND if the [attestor][google.cloud.binaryauthorization.v1beta1.Attestor] does not exist." ] pub async fn get_attestor ( & mut self , request : impl tonic :: IntoRequest < super :: GetAttestorRequest > , ) -> Result < tonic :: Response < super :: Attestor > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.binaryauthorization.v1beta1.BinauthzManagementServiceV1Beta1/GetAttestor" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an [attestor][google.cloud.binaryauthorization.v1beta1.Attestor]." ] # [ doc = " Returns NOT_FOUND if the [attestor][google.cloud.binaryauthorization.v1beta1.Attestor] does not exist." ] pub async fn update_attestor ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateAttestorRequest > , ) -> Result < tonic :: Response < super :: Attestor > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.binaryauthorization.v1beta1.BinauthzManagementServiceV1Beta1/UpdateAttestor" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists [attestors][google.cloud.binaryauthorization.v1beta1.Attestor]." ] # [ doc = " Returns INVALID_ARGUMENT if the project does not exist." ] pub async fn list_attestors ( & mut self , request : impl tonic :: IntoRequest < super :: ListAttestorsRequest > , ) -> Result < tonic :: Response < super :: ListAttestorsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.binaryauthorization.v1beta1.BinauthzManagementServiceV1Beta1/ListAttestors" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an [attestor][google.cloud.binaryauthorization.v1beta1.Attestor]. Returns NOT_FOUND if the" ] # [ doc = " [attestor][google.cloud.binaryauthorization.v1beta1.Attestor] does not exist." ] pub async fn delete_attestor ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAttestorRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.binaryauthorization.v1beta1.BinauthzManagementServiceV1Beta1/DeleteAttestor" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BinauthzManagementServiceV1Beta1Client < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BinauthzManagementServiceV1Beta1Client < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BinauthzManagementServiceV1Beta1Client {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/kms/v1.rs:1034:22890 [INFO] [stdout] | [INFO] [stdout] 1034 | # [ doc = r" Generated client implementations." ] pub mod key_management_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Google Cloud Key Management Service" ] # [ doc = "" ] # [ doc = " Manages cryptographic keys and operations using those keys. Implements a REST" ] # [ doc = " model with the following objects:" ] # [ doc = "" ] # [ doc = " * [KeyRing][google.cloud.kms.v1.KeyRing]" ] # [ doc = " * [CryptoKey][google.cloud.kms.v1.CryptoKey]" ] # [ doc = " * [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion]" ] # [ doc = " * [ImportJob][google.cloud.kms.v1.ImportJob]" ] # [ doc = "" ] # [ doc = " If you are using manual gRPC libraries, see" ] # [ doc = " [Using gRPC with Cloud KMS](https://cloud.google.com/kms/docs/grpc)." ] pub struct KeyManagementServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > KeyManagementServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists [KeyRings][google.cloud.kms.v1.KeyRing]." ] pub async fn list_key_rings ( & mut self , request : impl tonic :: IntoRequest < super :: ListKeyRingsRequest > , ) -> Result < tonic :: Response < super :: ListKeyRingsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/ListKeyRings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists [CryptoKeys][google.cloud.kms.v1.CryptoKey]." ] pub async fn list_crypto_keys ( & mut self , request : impl tonic :: IntoRequest < super :: ListCryptoKeysRequest > , ) -> Result < tonic :: Response < super :: ListCryptoKeysResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/ListCryptoKeys" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists [CryptoKeyVersions][google.cloud.kms.v1.CryptoKeyVersion]." ] pub async fn list_crypto_key_versions ( & mut self , request : impl tonic :: IntoRequest < super :: ListCryptoKeyVersionsRequest > , ) -> Result < tonic :: Response < super :: ListCryptoKeyVersionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/ListCryptoKeyVersions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists [ImportJobs][google.cloud.kms.v1.ImportJob]." ] pub async fn list_import_jobs ( & mut self , request : impl tonic :: IntoRequest < super :: ListImportJobsRequest > , ) -> Result < tonic :: Response < super :: ListImportJobsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/ListImportJobs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns metadata for a given [KeyRing][google.cloud.kms.v1.KeyRing]." ] pub async fn get_key_ring ( & mut self , request : impl tonic :: IntoRequest < super :: GetKeyRingRequest > , ) -> Result < tonic :: Response < super :: KeyRing > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/GetKeyRing" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns metadata for a given [CryptoKey][google.cloud.kms.v1.CryptoKey], as well as its" ] # [ doc = " [primary][google.cloud.kms.v1.CryptoKey.primary] [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion]." ] pub async fn get_crypto_key ( & mut self , request : impl tonic :: IntoRequest < super :: GetCryptoKeyRequest > , ) -> Result < tonic :: Response < super :: CryptoKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/GetCryptoKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns metadata for a given [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion]." ] pub async fn get_crypto_key_version ( & mut self , request : impl tonic :: IntoRequest < super :: GetCryptoKeyVersionRequest > , ) -> Result < tonic :: Response < super :: CryptoKeyVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/GetCryptoKeyVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the public key for the given [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion]. The" ] # [ doc = " [CryptoKey.purpose][google.cloud.kms.v1.CryptoKey.purpose] must be" ] # [ doc = " [ASYMMETRIC_SIGN][google.cloud.kms.v1.CryptoKey.CryptoKeyPurpose.ASYMMETRIC_SIGN] or" ] # [ doc = " [ASYMMETRIC_DECRYPT][google.cloud.kms.v1.CryptoKey.CryptoKeyPurpose.ASYMMETRIC_DECRYPT]." ] pub async fn get_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: GetPublicKeyRequest > , ) -> Result < tonic :: Response < super :: PublicKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/GetPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns metadata for a given [ImportJob][google.cloud.kms.v1.ImportJob]." ] pub async fn get_import_job ( & mut self , request : impl tonic :: IntoRequest < super :: GetImportJobRequest > , ) -> Result < tonic :: Response < super :: ImportJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/GetImportJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create a new [KeyRing][google.cloud.kms.v1.KeyRing] in a given Project and Location." ] pub async fn create_key_ring ( & mut self , request : impl tonic :: IntoRequest < super :: CreateKeyRingRequest > , ) -> Result < tonic :: Response < super :: KeyRing > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/CreateKeyRing" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create a new [CryptoKey][google.cloud.kms.v1.CryptoKey] within a [KeyRing][google.cloud.kms.v1.KeyRing]." ] # [ doc = "" ] # [ doc = " [CryptoKey.purpose][google.cloud.kms.v1.CryptoKey.purpose] and" ] # [ doc = " [CryptoKey.version_template.algorithm][google.cloud.kms.v1.CryptoKeyVersionTemplate.algorithm]" ] # [ doc = " are required." ] pub async fn create_crypto_key ( & mut self , request : impl tonic :: IntoRequest < super :: CreateCryptoKeyRequest > , ) -> Result < tonic :: Response < super :: CryptoKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/CreateCryptoKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create a new [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion] in a [CryptoKey][google.cloud.kms.v1.CryptoKey]." ] # [ doc = "" ] # [ doc = " The server will assign the next sequential id. If unset," ] # [ doc = " [state][google.cloud.kms.v1.CryptoKeyVersion.state] will be set to" ] # [ doc = " [ENABLED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.ENABLED]." ] pub async fn create_crypto_key_version ( & mut self , request : impl tonic :: IntoRequest < super :: CreateCryptoKeyVersionRequest > , ) -> Result < tonic :: Response < super :: CryptoKeyVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/CreateCryptoKeyVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Imports a new [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion] into an existing [CryptoKey][google.cloud.kms.v1.CryptoKey] using the" ] # [ doc = " wrapped key material provided in the request." ] # [ doc = "" ] # [ doc = " The version ID will be assigned the next sequential id within the" ] # [ doc = " [CryptoKey][google.cloud.kms.v1.CryptoKey]." ] pub async fn import_crypto_key_version ( & mut self , request : impl tonic :: IntoRequest < super :: ImportCryptoKeyVersionRequest > , ) -> Result < tonic :: Response < super :: CryptoKeyVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/ImportCryptoKeyVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create a new [ImportJob][google.cloud.kms.v1.ImportJob] within a [KeyRing][google.cloud.kms.v1.KeyRing]." ] # [ doc = "" ] # [ doc = " [ImportJob.import_method][google.cloud.kms.v1.ImportJob.import_method] is required." ] pub async fn create_import_job ( & mut self , request : impl tonic :: IntoRequest < super :: CreateImportJobRequest > , ) -> Result < tonic :: Response < super :: ImportJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/CreateImportJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Update a [CryptoKey][google.cloud.kms.v1.CryptoKey]." ] pub async fn update_crypto_key ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateCryptoKeyRequest > , ) -> Result < tonic :: Response < super :: CryptoKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/UpdateCryptoKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Update a [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion]'s metadata." ] # [ doc = "" ] # [ doc = " [state][google.cloud.kms.v1.CryptoKeyVersion.state] may be changed between" ] # [ doc = " [ENABLED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.ENABLED] and" ] # [ doc = " [DISABLED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.DISABLED] using this" ] # [ doc = " method. See [DestroyCryptoKeyVersion][google.cloud.kms.v1.KeyManagementService.DestroyCryptoKeyVersion] and [RestoreCryptoKeyVersion][google.cloud.kms.v1.KeyManagementService.RestoreCryptoKeyVersion] to" ] # [ doc = " move between other states." ] pub async fn update_crypto_key_version ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateCryptoKeyVersionRequest > , ) -> Result < tonic :: Response < super :: CryptoKeyVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/UpdateCryptoKeyVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Encrypts data, so that it can only be recovered by a call to [Decrypt][google.cloud.kms.v1.KeyManagementService.Decrypt]." ] # [ doc = " The [CryptoKey.purpose][google.cloud.kms.v1.CryptoKey.purpose] must be" ] # [ doc = " [ENCRYPT_DECRYPT][google.cloud.kms.v1.CryptoKey.CryptoKeyPurpose.ENCRYPT_DECRYPT]." ] pub async fn encrypt ( & mut self , request : impl tonic :: IntoRequest < super :: EncryptRequest > , ) -> Result < tonic :: Response < super :: EncryptResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/Encrypt" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Decrypts data that was protected by [Encrypt][google.cloud.kms.v1.KeyManagementService.Encrypt]. The [CryptoKey.purpose][google.cloud.kms.v1.CryptoKey.purpose]" ] # [ doc = " must be [ENCRYPT_DECRYPT][google.cloud.kms.v1.CryptoKey.CryptoKeyPurpose.ENCRYPT_DECRYPT]." ] pub async fn decrypt ( & mut self , request : impl tonic :: IntoRequest < super :: DecryptRequest > , ) -> Result < tonic :: Response < super :: DecryptResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/Decrypt" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signs data using a [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion] with [CryptoKey.purpose][google.cloud.kms.v1.CryptoKey.purpose]" ] # [ doc = " ASYMMETRIC_SIGN, producing a signature that can be verified with the public" ] # [ doc = " key retrieved from [GetPublicKey][google.cloud.kms.v1.KeyManagementService.GetPublicKey]." ] pub async fn asymmetric_sign ( & mut self , request : impl tonic :: IntoRequest < super :: AsymmetricSignRequest > , ) -> Result < tonic :: Response < super :: AsymmetricSignResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/AsymmetricSign" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Decrypts data that was encrypted with a public key retrieved from" ] # [ doc = " [GetPublicKey][google.cloud.kms.v1.KeyManagementService.GetPublicKey] corresponding to a [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion] with" ] # [ doc = " [CryptoKey.purpose][google.cloud.kms.v1.CryptoKey.purpose] ASYMMETRIC_DECRYPT." ] pub async fn asymmetric_decrypt ( & mut self , request : impl tonic :: IntoRequest < super :: AsymmetricDecryptRequest > , ) -> Result < tonic :: Response < super :: AsymmetricDecryptResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/AsymmetricDecrypt" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Update the version of a [CryptoKey][google.cloud.kms.v1.CryptoKey] that will be used in [Encrypt][google.cloud.kms.v1.KeyManagementService.Encrypt]." ] # [ doc = "" ] # [ doc = " Returns an error if called on an asymmetric key." ] pub async fn update_crypto_key_primary_version ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateCryptoKeyPrimaryVersionRequest > , ) -> Result < tonic :: Response < super :: CryptoKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/UpdateCryptoKeyPrimaryVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Schedule a [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion] for destruction." ] # [ doc = "" ] # [ doc = " Upon calling this method, [CryptoKeyVersion.state][google.cloud.kms.v1.CryptoKeyVersion.state] will be set to" ] # [ doc = " [DESTROY_SCHEDULED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.DESTROY_SCHEDULED]" ] # [ doc = " and [destroy_time][google.cloud.kms.v1.CryptoKeyVersion.destroy_time] will be set to a time 24" ] # [ doc = " hours in the future, at which point the [state][google.cloud.kms.v1.CryptoKeyVersion.state]" ] # [ doc = " will be changed to" ] # [ doc = " [DESTROYED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.DESTROYED], and the key" ] # [ doc = " material will be irrevocably destroyed." ] # [ doc = "" ] # [ doc = " Before the [destroy_time][google.cloud.kms.v1.CryptoKeyVersion.destroy_time] is reached," ] # [ doc = " [RestoreCryptoKeyVersion][google.cloud.kms.v1.KeyManagementService.RestoreCryptoKeyVersion] may be called to reverse the process." ] pub async fn destroy_crypto_key_version ( & mut self , request : impl tonic :: IntoRequest < super :: DestroyCryptoKeyVersionRequest > , ) -> Result < tonic :: Response < super :: CryptoKeyVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/DestroyCryptoKeyVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Restore a [CryptoKeyVersion][google.cloud.kms.v1.CryptoKeyVersion] in the" ] # [ doc = " [DESTROY_SCHEDULED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.DESTROY_SCHEDULED]" ] # [ doc = " state." ] # [ doc = "" ] # [ doc = " Upon restoration of the CryptoKeyVersion, [state][google.cloud.kms.v1.CryptoKeyVersion.state]" ] # [ doc = " will be set to [DISABLED][google.cloud.kms.v1.CryptoKeyVersion.CryptoKeyVersionState.DISABLED]," ] # [ doc = " and [destroy_time][google.cloud.kms.v1.CryptoKeyVersion.destroy_time] will be cleared." ] pub async fn restore_crypto_key_version ( & mut self , request : impl tonic :: IntoRequest < super :: RestoreCryptoKeyVersionRequest > , ) -> Result < tonic :: Response < super :: CryptoKeyVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.kms.v1.KeyManagementService/RestoreCryptoKeyVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for KeyManagementServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for KeyManagementServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "KeyManagementServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/runtimeconfig/v1beta1.rs:485:14471 [INFO] [stdout] | [INFO] [stdout] 485 | # [ doc = r" Generated client implementations." ] pub mod runtime_config_manager_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " RuntimeConfig API represents configuration objects and operations on those" ] # [ doc = " configuration objects." ] # [ doc = " RuntimeConfig objects consist of Variables logically grouped in the those" ] # [ doc = " objects." ] # [ doc = " Variables are simple key-value pairs. Variables can be watched for changes or" ] # [ doc = " deletions. Variable key can be hieararchical, e.g. ports/serving_port," ] # [ doc = " ports/monitoring_port, etc. Variable names can be hierarchical. No variable" ] # [ doc = " name can be prefix of another." ] # [ doc = " Config objects represent logical containers for variables, e.g. flags," ] # [ doc = " passwords, etc." ] pub struct RuntimeConfigManagerClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > RuntimeConfigManagerClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists all the RuntimeConfig resources within project." ] pub async fn list_configs ( & mut self , request : impl tonic :: IntoRequest < super :: ListConfigsRequest > , ) -> Result < tonic :: Response < super :: ListConfigsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/ListConfigs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a RuntimeConfig resource." ] pub async fn get_config ( & mut self , request : impl tonic :: IntoRequest < super :: GetConfigRequest > , ) -> Result < tonic :: Response < super :: RuntimeConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/GetConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new RuntimeConfig resource. The configuration name must be" ] # [ doc = " unique within project." ] pub async fn create_config ( & mut self , request : impl tonic :: IntoRequest < super :: CreateConfigRequest > , ) -> Result < tonic :: Response < super :: RuntimeConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/CreateConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a RuntimeConfig resource. The configuration must exist beforehand." ] pub async fn update_config ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateConfigRequest > , ) -> Result < tonic :: Response < super :: RuntimeConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/UpdateConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a RuntimeConfig resource." ] pub async fn delete_config ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteConfigRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/DeleteConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists variables within given a configuration, matching any provided" ] # [ doc = " filters. This only lists variable names, not the values, unless" ] # [ doc = " `return_values` is true, in which case only variables that user has IAM" ] # [ doc = " permission to GetVariable will be returned." ] pub async fn list_variables ( & mut self , request : impl tonic :: IntoRequest < super :: ListVariablesRequest > , ) -> Result < tonic :: Response < super :: ListVariablesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/ListVariables" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a single variable." ] pub async fn get_variable ( & mut self , request : impl tonic :: IntoRequest < super :: GetVariableRequest > , ) -> Result < tonic :: Response < super :: Variable > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/GetVariable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Watches a specific variable and waits for a change in the variable's value." ] # [ doc = " When there is a change, this method returns the new value or times out." ] # [ doc = "" ] # [ doc = " If a variable is deleted while being watched, the `variableState` state is" ] # [ doc = " set to `DELETED` and the method returns the last known variable `value`." ] # [ doc = "" ] # [ doc = " If you set the deadline for watching to a larger value than internal" ] # [ doc = " timeout (60 seconds), the current variable value is returned and the" ] # [ doc = " `variableState` will be `VARIABLE_STATE_UNSPECIFIED`." ] # [ doc = "" ] # [ doc = " To learn more about creating a watcher, read the" ] # [ doc = " [Watching a Variable for" ] # [ doc = " Changes](/deployment-manager/runtime-configurator/watching-a-variable)" ] # [ doc = " documentation." ] pub async fn watch_variable ( & mut self , request : impl tonic :: IntoRequest < super :: WatchVariableRequest > , ) -> Result < tonic :: Response < super :: Variable > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/WatchVariable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a variable within the given configuration. You cannot create" ] # [ doc = " a variable with a name that is a prefix of an existing variable name, or a" ] # [ doc = " name that has an existing variable name as a prefix." ] # [ doc = "" ] # [ doc = " To learn more about creating a variable, read the" ] # [ doc = " [Setting and Getting" ] # [ doc = " Data](/deployment-manager/runtime-configurator/set-and-get-variables)" ] # [ doc = " documentation." ] pub async fn create_variable ( & mut self , request : impl tonic :: IntoRequest < super :: CreateVariableRequest > , ) -> Result < tonic :: Response < super :: Variable > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/CreateVariable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing variable with a new value." ] pub async fn update_variable ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateVariableRequest > , ) -> Result < tonic :: Response < super :: Variable > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/UpdateVariable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a variable or multiple variables." ] # [ doc = "" ] # [ doc = " If you specify a variable name, then that variable is deleted. If you" ] # [ doc = " specify a prefix and `recursive` is true, then all variables with that" ] # [ doc = " prefix are deleted. You must set a `recursive` to true if you delete" ] # [ doc = " variables by prefix." ] pub async fn delete_variable ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteVariableRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/DeleteVariable" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List waiters within the given configuration." ] pub async fn list_waiters ( & mut self , request : impl tonic :: IntoRequest < super :: ListWaitersRequest > , ) -> Result < tonic :: Response < super :: ListWaitersResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/ListWaiters" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a single waiter." ] pub async fn get_waiter ( & mut self , request : impl tonic :: IntoRequest < super :: GetWaiterRequest > , ) -> Result < tonic :: Response < super :: Waiter > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/GetWaiter" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a Waiter resource. This operation returns a long-running Operation" ] # [ doc = " resource which can be polled for completion. However, a waiter with the" ] # [ doc = " given name will exist (and can be retrieved) prior to the operation" ] # [ doc = " completing. If the operation fails, the failed Waiter resource will" ] # [ doc = " still exist and must be deleted prior to subsequent creation attempts." ] pub async fn create_waiter ( & mut self , request : impl tonic :: IntoRequest < super :: CreateWaiterRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/CreateWaiter" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the waiter with the specified name." ] pub async fn delete_waiter ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteWaiterRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.runtimeconfig.v1beta1.RuntimeConfigManager/DeleteWaiter" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for RuntimeConfigManagerClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for RuntimeConfigManagerClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "RuntimeConfigManagerClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/gaming/v1beta.rs:1018:21910 [INFO] [stdout] | [INFO] [stdout] 1018 | # [ doc = r" Generated client implementations." ] pub mod game_server_deployments_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The Game Server Deployment is used to control the deployment of Agones" ] # [ doc = " fleets." ] pub struct GameServerDeploymentsServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > GameServerDeploymentsServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists Game Server Deployments in a given project and Location." ] pub async fn list_game_server_deployments ( & mut self , request : impl tonic :: IntoRequest < super :: ListGameServerDeploymentsRequest > , ) -> Result < tonic :: Response < super :: ListGameServerDeploymentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/ListGameServerDeployments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets details of a single Game Server Deployment." ] pub async fn get_game_server_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: GetGameServerDeploymentRequest > , ) -> Result < tonic :: Response < super :: GameServerDeployment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/GetGameServerDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new Game Server Deployment in a given project and Location." ] pub async fn create_game_server_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: CreateGameServerDeploymentRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/CreateGameServerDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a single Game Server Deployment." ] pub async fn delete_game_server_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteGameServerDeploymentRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/DeleteGameServerDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Patches a Game Server Deployment." ] pub async fn update_game_server_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateGameServerDeploymentRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/UpdateGameServerDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets details a single Game Server Deployment Rollout." ] pub async fn get_game_server_deployment_rollout ( & mut self , request : impl tonic :: IntoRequest < super :: GetGameServerDeploymentRolloutRequest > , ) -> Result < tonic :: Response < super :: GameServerDeploymentRollout > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/GetGameServerDeploymentRollout" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Patches a single Game Server Deployment Rollout." ] # [ doc = " The method will not return an error if the update does not affect any" ] # [ doc = " existing realms. For example - if the default_game_server_config is changed" ] # [ doc = " but all existing realms use the override, that is valid. Similarly, if a" ] # [ doc = " non existing realm is explicitly called out in game_server_config_overrides" ] # [ doc = " field, that will also not result in an error." ] pub async fn update_game_server_deployment_rollout ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateGameServerDeploymentRolloutRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/UpdateGameServerDeploymentRollout" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Previews the Game Server Deployment Rollout. This API does not mutate the" ] # [ doc = " Rollout resource." ] pub async fn preview_game_server_deployment_rollout ( & mut self , request : impl tonic :: IntoRequest < super :: PreviewGameServerDeploymentRolloutRequest > , ) -> Result < tonic :: Response < super :: PreviewGameServerDeploymentRolloutResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/PreviewGameServerDeploymentRollout" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves information about the current state of the Game Server" ] # [ doc = " Ddeployment. Gathers all the Agones fleets and Agones autoscalers," ] # [ doc = " including fleets running an older version of the Game Server Deployment." ] pub async fn fetch_deployment_state ( & mut self , request : impl tonic :: IntoRequest < super :: FetchDeploymentStateRequest > , ) -> Result < tonic :: Response < super :: FetchDeploymentStateResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerDeploymentsService/FetchDeploymentState" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for GameServerDeploymentsServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for GameServerDeploymentsServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "GameServerDeploymentsServiceClient {{ ... }}" ) } } }# [ doc = r" Generated client implementations." ] pub mod realms_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " A Realm is a grouping of Game Server Clusters that are considered" ] # [ doc = " interchangeable." ] pub struct RealmsServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > RealmsServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists Realms in a given project and Location." ] pub async fn list_realms ( & mut self , request : impl tonic :: IntoRequest < super :: ListRealmsRequest > , ) -> Result < tonic :: Response < super :: ListRealmsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.RealmsService/ListRealms" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets details of a single Realm." ] pub async fn get_realm ( & mut self , request : impl tonic :: IntoRequest < super :: GetRealmRequest > , ) -> Result < tonic :: Response < super :: Realm > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.RealmsService/GetRealm" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new Realm in a given project and Location." ] pub async fn create_realm ( & mut self , request : impl tonic :: IntoRequest < super :: CreateRealmRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.RealmsService/CreateRealm" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a single Realm." ] pub async fn delete_realm ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteRealmRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.RealmsService/DeleteRealm" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Patches a single Realm." ] pub async fn update_realm ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateRealmRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.RealmsService/UpdateRealm" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Previews patches to a single Realm." ] pub async fn preview_realm_update ( & mut self , request : impl tonic :: IntoRequest < super :: PreviewRealmUpdateRequest > , ) -> Result < tonic :: Response < super :: PreviewRealmUpdateResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.RealmsService/PreviewRealmUpdate" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for RealmsServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for RealmsServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "RealmsServiceClient {{ ... }}" ) } } }# [ doc = r" Generated client implementations." ] pub mod game_server_clusters_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The game server cluster maps to Kubernetes clusters running Agones and is" ] # [ doc = " used to manage fleets within clusters." ] pub struct GameServerClustersServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > GameServerClustersServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists Game Server Clusters in a given project and location." ] pub async fn list_game_server_clusters ( & mut self , request : impl tonic :: IntoRequest < super :: ListGameServerClustersRequest > , ) -> Result < tonic :: Response < super :: ListGameServerClustersResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerClustersService/ListGameServerClusters" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets details of a single game server cluster." ] pub async fn get_game_server_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: GetGameServerClusterRequest > , ) -> Result < tonic :: Response < super :: GameServerCluster > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerClustersService/GetGameServerCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new game server cluster in a given project and location." ] pub async fn create_game_server_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: CreateGameServerClusterRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerClustersService/CreateGameServerCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Previews creation of a new game server cluster in a given project and" ] # [ doc = " location." ] pub async fn preview_create_game_server_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: PreviewCreateGameServerClusterRequest > , ) -> Result < tonic :: Response < super :: PreviewCreateGameServerClusterResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerClustersService/PreviewCreateGameServerCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a single game server cluster." ] pub async fn delete_game_server_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteGameServerClusterRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerClustersService/DeleteGameServerCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Previews deletion of a single game server cluster." ] pub async fn preview_delete_game_server_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: PreviewDeleteGameServerClusterRequest > , ) -> Result < tonic :: Response < super :: PreviewDeleteGameServerClusterResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerClustersService/PreviewDeleteGameServerCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Patches a single game server cluster." ] pub async fn update_game_server_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateGameServerClusterRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerClustersService/UpdateGameServerCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Previews updating a GameServerCluster." ] pub async fn preview_update_game_server_cluster ( & mut self , request : impl tonic :: IntoRequest < super :: PreviewUpdateGameServerClusterRequest > , ) -> Result < tonic :: Response < super :: PreviewUpdateGameServerClusterResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.gaming.v1beta.GameServerClustersService/PreviewUpdateGameServerCluster" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for GameServerClustersServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for GameServerClustersServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "GameServerClustersServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/tasks/v2beta2.rs:1363:25018 [INFO] [stdout] | [INFO] [stdout] 1363 | # [ doc = r" Generated client implementations." ] pub mod cloud_tasks_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud Tasks allows developers to manage the execution of background" ] # [ doc = " work in their applications." ] pub struct CloudTasksClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudTasksClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists queues." ] # [ doc = "" ] # [ doc = " Queues are returned in lexicographical order." ] pub async fn list_queues ( & mut self , request : impl tonic :: IntoRequest < super :: ListQueuesRequest > , ) -> Result < tonic :: Response < super :: ListQueuesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/ListQueues" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a queue." ] pub async fn get_queue ( & mut self , request : impl tonic :: IntoRequest < super :: GetQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/GetQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a queue." ] # [ doc = "" ] # [ doc = " Queues created with this method allow tasks to live for a maximum of 31" ] # [ doc = " days. After a task is 31 days old, the task will be deleted regardless of whether" ] # [ doc = " it was dispatched or not." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn create_queue ( & mut self , request : impl tonic :: IntoRequest < super :: CreateQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/CreateQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a queue." ] # [ doc = "" ] # [ doc = " This method creates the queue if it does not exist and updates" ] # [ doc = " the queue if it does exist." ] # [ doc = "" ] # [ doc = " Queues created with this method allow tasks to live for a maximum of 31" ] # [ doc = " days. After a task is 31 days old, the task will be deleted regardless of whether" ] # [ doc = " it was dispatched or not." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn update_queue ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/UpdateQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a queue." ] # [ doc = "" ] # [ doc = " This command will delete the queue even if it has tasks in it." ] # [ doc = "" ] # [ doc = " Note: If you delete a queue, a queue with the same name can't be created" ] # [ doc = " for 7 days." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn delete_queue ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteQueueRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/DeleteQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Purges a queue by deleting all of its tasks." ] # [ doc = "" ] # [ doc = " All tasks created before this method is called are permanently deleted." ] # [ doc = "" ] # [ doc = " Purge operations can take up to one minute to take effect. Tasks" ] # [ doc = " might be dispatched before the purge takes effect. A purge is irreversible." ] pub async fn purge_queue ( & mut self , request : impl tonic :: IntoRequest < super :: PurgeQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/PurgeQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Pauses the queue." ] # [ doc = "" ] # [ doc = " If a queue is paused then the system will stop dispatching tasks" ] # [ doc = " until the queue is resumed via" ] # [ doc = " [ResumeQueue][google.cloud.tasks.v2beta2.CloudTasks.ResumeQueue]. Tasks can still be added" ] # [ doc = " when the queue is paused. A queue is paused if its" ] # [ doc = " [state][google.cloud.tasks.v2beta2.Queue.state] is [PAUSED][google.cloud.tasks.v2beta2.Queue.State.PAUSED]." ] pub async fn pause_queue ( & mut self , request : impl tonic :: IntoRequest < super :: PauseQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/PauseQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Resume a queue." ] # [ doc = "" ] # [ doc = " This method resumes a queue after it has been" ] # [ doc = " [PAUSED][google.cloud.tasks.v2beta2.Queue.State.PAUSED] or" ] # [ doc = " [DISABLED][google.cloud.tasks.v2beta2.Queue.State.DISABLED]. The state of a queue is stored" ] # [ doc = " in the queue's [state][google.cloud.tasks.v2beta2.Queue.state]; after calling this method it" ] # [ doc = " will be set to [RUNNING][google.cloud.tasks.v2beta2.Queue.State.RUNNING]." ] # [ doc = "" ] # [ doc = " WARNING: Resuming many high-QPS queues at the same time can" ] # [ doc = " lead to target overloading. If you are resuming high-QPS" ] # [ doc = " queues, follow the 500/50/5 pattern described in" ] # [ doc = " [Managing Cloud Tasks Scaling" ] # [ doc = " Risks](https://cloud.google.com/tasks/docs/manage-cloud-task-scaling)." ] pub async fn resume_queue ( & mut self , request : impl tonic :: IntoRequest < super :: ResumeQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/ResumeQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a [Queue][google.cloud.tasks.v2beta2.Queue]." ] # [ doc = " Returns an empty policy if the resource exists and does not have a policy" ] # [ doc = " set." ] # [ doc = "" ] # [ doc = " Authorization requires the following" ] # [ doc = " [Google IAM](https://cloud.google.com/iam) permission on the specified" ] # [ doc = " resource parent:" ] # [ doc = "" ] # [ doc = " * `cloudtasks.queues.getIamPolicy`" ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy for a [Queue][google.cloud.tasks.v2beta2.Queue]. Replaces any existing" ] # [ doc = " policy." ] # [ doc = "" ] # [ doc = " Note: The Cloud Console does not check queue-level IAM permissions yet." ] # [ doc = " Project-level permissions are required to use the Cloud Console." ] # [ doc = "" ] # [ doc = " Authorization requires the following" ] # [ doc = " [Google IAM](https://cloud.google.com/iam) permission on the specified" ] # [ doc = " resource parent:" ] # [ doc = "" ] # [ doc = " * `cloudtasks.queues.setIamPolicy`" ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has on a [Queue][google.cloud.tasks.v2beta2.Queue]." ] # [ doc = " If the resource does not exist, this will return an empty set of" ] # [ doc = " permissions, not a [NOT_FOUND][google.rpc.Code.NOT_FOUND] error." ] # [ doc = "" ] # [ doc = " Note: This operation is designed to be used for building permission-aware" ] # [ doc = " UIs and command-line tools, not for authorization checking. This operation" ] # [ doc = " may \"fail open\" without warning." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the tasks in a queue." ] # [ doc = "" ] # [ doc = " By default, only the [BASIC][google.cloud.tasks.v2beta2.Task.View.BASIC] view is retrieved" ] # [ doc = " due to performance considerations;" ] # [ doc = " [response_view][google.cloud.tasks.v2beta2.ListTasksRequest.response_view] controls the" ] # [ doc = " subset of information which is returned." ] # [ doc = "" ] # [ doc = " The tasks may be returned in any order. The ordering may change at any" ] # [ doc = " time." ] pub async fn list_tasks ( & mut self , request : impl tonic :: IntoRequest < super :: ListTasksRequest > , ) -> Result < tonic :: Response < super :: ListTasksResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/ListTasks" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a task." ] pub async fn get_task ( & mut self , request : impl tonic :: IntoRequest < super :: GetTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/GetTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a task and adds it to a queue." ] # [ doc = "" ] # [ doc = " Tasks cannot be updated after creation; there is no UpdateTask command." ] # [ doc = "" ] # [ doc = " * For [App Engine queues][google.cloud.tasks.v2beta2.AppEngineHttpTarget], the maximum task size is" ] # [ doc = " 100KB." ] # [ doc = " * For [pull queues][google.cloud.tasks.v2beta2.PullTarget], the maximum task size is 1MB." ] pub async fn create_task ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/CreateTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a task." ] # [ doc = "" ] # [ doc = " A task can be deleted if it is scheduled or dispatched. A task" ] # [ doc = " cannot be deleted if it has completed successfully or permanently" ] # [ doc = " failed." ] pub async fn delete_task ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTaskRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/DeleteTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Leases tasks from a pull queue for" ] # [ doc = " [lease_duration][google.cloud.tasks.v2beta2.LeaseTasksRequest.lease_duration]." ] # [ doc = "" ] # [ doc = " This method is invoked by the worker to obtain a lease. The" ] # [ doc = " worker must acknowledge the task via" ] # [ doc = " [AcknowledgeTask][google.cloud.tasks.v2beta2.CloudTasks.AcknowledgeTask] after they have" ] # [ doc = " performed the work associated with the task." ] # [ doc = "" ] # [ doc = " The [payload][google.cloud.tasks.v2beta2.PullMessage.payload] is intended to store data that" ] # [ doc = " the worker needs to perform the work associated with the task. To" ] # [ doc = " return the payloads in the [response][google.cloud.tasks.v2beta2.LeaseTasksResponse], set" ] # [ doc = " [response_view][google.cloud.tasks.v2beta2.LeaseTasksRequest.response_view] to" ] # [ doc = " [FULL][google.cloud.tasks.v2beta2.Task.View.FULL]." ] # [ doc = "" ] # [ doc = " A maximum of 10 qps of [LeaseTasks][google.cloud.tasks.v2beta2.CloudTasks.LeaseTasks]" ] # [ doc = " requests are allowed per" ] # [ doc = " queue. [RESOURCE_EXHAUSTED][google.rpc.Code.RESOURCE_EXHAUSTED]" ] # [ doc = " is returned when this limit is" ] # [ doc = " exceeded. [RESOURCE_EXHAUSTED][google.rpc.Code.RESOURCE_EXHAUSTED]" ] # [ doc = " is also returned when" ] # [ doc = " [max_tasks_dispatched_per_second][google.cloud.tasks.v2beta2.RateLimits.max_tasks_dispatched_per_second]" ] # [ doc = " is exceeded." ] pub async fn lease_tasks ( & mut self , request : impl tonic :: IntoRequest < super :: LeaseTasksRequest > , ) -> Result < tonic :: Response < super :: LeaseTasksResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/LeaseTasks" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Acknowledges a pull task." ] # [ doc = "" ] # [ doc = " The worker, that is, the entity that" ] # [ doc = " [leased][google.cloud.tasks.v2beta2.CloudTasks.LeaseTasks] this task must call this method" ] # [ doc = " to indicate that the work associated with the task has finished." ] # [ doc = "" ] # [ doc = " The worker must acknowledge a task within the" ] # [ doc = " [lease_duration][google.cloud.tasks.v2beta2.LeaseTasksRequest.lease_duration] or the lease" ] # [ doc = " will expire and the task will become available to be leased" ] # [ doc = " again. After the task is acknowledged, it will not be returned" ] # [ doc = " by a later [LeaseTasks][google.cloud.tasks.v2beta2.CloudTasks.LeaseTasks]," ] # [ doc = " [GetTask][google.cloud.tasks.v2beta2.CloudTasks.GetTask], or" ] # [ doc = " [ListTasks][google.cloud.tasks.v2beta2.CloudTasks.ListTasks]." ] pub async fn acknowledge_task ( & mut self , request : impl tonic :: IntoRequest < super :: AcknowledgeTaskRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/AcknowledgeTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Renew the current lease of a pull task." ] # [ doc = "" ] # [ doc = " The worker can use this method to extend the lease by a new" ] # [ doc = " duration, starting from now. The new task lease will be" ] # [ doc = " returned in the task's [schedule_time][google.cloud.tasks.v2beta2.Task.schedule_time]." ] pub async fn renew_lease ( & mut self , request : impl tonic :: IntoRequest < super :: RenewLeaseRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/RenewLease" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Cancel a pull task's lease." ] # [ doc = "" ] # [ doc = " The worker can use this method to cancel a task's lease by" ] # [ doc = " setting its [schedule_time][google.cloud.tasks.v2beta2.Task.schedule_time] to now. This will" ] # [ doc = " make the task available to be leased to the next caller of" ] # [ doc = " [LeaseTasks][google.cloud.tasks.v2beta2.CloudTasks.LeaseTasks]." ] pub async fn cancel_lease ( & mut self , request : impl tonic :: IntoRequest < super :: CancelLeaseRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/CancelLease" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Forces a task to run now." ] # [ doc = "" ] # [ doc = " When this method is called, Cloud Tasks will dispatch the task, even if" ] # [ doc = " the task is already running, the queue has reached its [RateLimits][google.cloud.tasks.v2beta2.RateLimits] or" ] # [ doc = " is [PAUSED][google.cloud.tasks.v2beta2.Queue.State.PAUSED]." ] # [ doc = "" ] # [ doc = " This command is meant to be used for manual debugging. For" ] # [ doc = " example, [RunTask][google.cloud.tasks.v2beta2.CloudTasks.RunTask] can be used to retry a failed" ] # [ doc = " task after a fix has been made or to manually force a task to be" ] # [ doc = " dispatched now." ] # [ doc = "" ] # [ doc = " The dispatched task is returned. That is, the task that is returned" ] # [ doc = " contains the [status][google.cloud.tasks.v2beta2.Task.status] after the task is dispatched but" ] # [ doc = " before the task is received by its target." ] # [ doc = "" ] # [ doc = " If Cloud Tasks receives a successful response from the task's" ] # [ doc = " target, then the task will be deleted; otherwise the task's" ] # [ doc = " [schedule_time][google.cloud.tasks.v2beta2.Task.schedule_time] will be reset to the time that" ] # [ doc = " [RunTask][google.cloud.tasks.v2beta2.CloudTasks.RunTask] was called plus the retry delay specified" ] # [ doc = " in the queue's [RetryConfig][google.cloud.tasks.v2beta2.RetryConfig]." ] # [ doc = "" ] # [ doc = " [RunTask][google.cloud.tasks.v2beta2.CloudTasks.RunTask] returns" ] # [ doc = " [NOT_FOUND][google.rpc.Code.NOT_FOUND] when it is called on a" ] # [ doc = " task that has already succeeded or permanently failed." ] # [ doc = "" ] # [ doc = " [RunTask][google.cloud.tasks.v2beta2.CloudTasks.RunTask] cannot be called on a" ] # [ doc = " [pull task][google.cloud.tasks.v2beta2.PullMessage]." ] pub async fn run_task ( & mut self , request : impl tonic :: IntoRequest < super :: RunTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta2.CloudTasks/RunTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudTasksClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudTasksClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudTasksClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/tasks/v2beta3.rs:1225:19150 [INFO] [stdout] | [INFO] [stdout] 1225 | # [ doc = r" Generated client implementations." ] pub mod cloud_tasks_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud Tasks allows developers to manage the execution of background" ] # [ doc = " work in their applications." ] pub struct CloudTasksClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudTasksClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists queues." ] # [ doc = "" ] # [ doc = " Queues are returned in lexicographical order." ] pub async fn list_queues ( & mut self , request : impl tonic :: IntoRequest < super :: ListQueuesRequest > , ) -> Result < tonic :: Response < super :: ListQueuesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/ListQueues" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a queue." ] pub async fn get_queue ( & mut self , request : impl tonic :: IntoRequest < super :: GetQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/GetQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a queue." ] # [ doc = "" ] # [ doc = " Queues created with this method allow tasks to live for a maximum of 31" ] # [ doc = " days. After a task is 31 days old, the task will be deleted regardless of whether" ] # [ doc = " it was dispatched or not." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn create_queue ( & mut self , request : impl tonic :: IntoRequest < super :: CreateQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/CreateQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a queue." ] # [ doc = "" ] # [ doc = " This method creates the queue if it does not exist and updates" ] # [ doc = " the queue if it does exist." ] # [ doc = "" ] # [ doc = " Queues created with this method allow tasks to live for a maximum of 31" ] # [ doc = " days. After a task is 31 days old, the task will be deleted regardless of whether" ] # [ doc = " it was dispatched or not." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn update_queue ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/UpdateQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a queue." ] # [ doc = "" ] # [ doc = " This command will delete the queue even if it has tasks in it." ] # [ doc = "" ] # [ doc = " Note: If you delete a queue, a queue with the same name can't be created" ] # [ doc = " for 7 days." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn delete_queue ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteQueueRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/DeleteQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Purges a queue by deleting all of its tasks." ] # [ doc = "" ] # [ doc = " All tasks created before this method is called are permanently deleted." ] # [ doc = "" ] # [ doc = " Purge operations can take up to one minute to take effect. Tasks" ] # [ doc = " might be dispatched before the purge takes effect. A purge is irreversible." ] pub async fn purge_queue ( & mut self , request : impl tonic :: IntoRequest < super :: PurgeQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/PurgeQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Pauses the queue." ] # [ doc = "" ] # [ doc = " If a queue is paused then the system will stop dispatching tasks" ] # [ doc = " until the queue is resumed via" ] # [ doc = " [ResumeQueue][google.cloud.tasks.v2beta3.CloudTasks.ResumeQueue]. Tasks can still be added" ] # [ doc = " when the queue is paused. A queue is paused if its" ] # [ doc = " [state][google.cloud.tasks.v2beta3.Queue.state] is [PAUSED][google.cloud.tasks.v2beta3.Queue.State.PAUSED]." ] pub async fn pause_queue ( & mut self , request : impl tonic :: IntoRequest < super :: PauseQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/PauseQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Resume a queue." ] # [ doc = "" ] # [ doc = " This method resumes a queue after it has been" ] # [ doc = " [PAUSED][google.cloud.tasks.v2beta3.Queue.State.PAUSED] or" ] # [ doc = " [DISABLED][google.cloud.tasks.v2beta3.Queue.State.DISABLED]. The state of a queue is stored" ] # [ doc = " in the queue's [state][google.cloud.tasks.v2beta3.Queue.state]; after calling this method it" ] # [ doc = " will be set to [RUNNING][google.cloud.tasks.v2beta3.Queue.State.RUNNING]." ] # [ doc = "" ] # [ doc = " WARNING: Resuming many high-QPS queues at the same time can" ] # [ doc = " lead to target overloading. If you are resuming high-QPS" ] # [ doc = " queues, follow the 500/50/5 pattern described in" ] # [ doc = " [Managing Cloud Tasks Scaling" ] # [ doc = " Risks](https://cloud.google.com/tasks/docs/manage-cloud-task-scaling)." ] pub async fn resume_queue ( & mut self , request : impl tonic :: IntoRequest < super :: ResumeQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/ResumeQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a [Queue][google.cloud.tasks.v2beta3.Queue]." ] # [ doc = " Returns an empty policy if the resource exists and does not have a policy" ] # [ doc = " set." ] # [ doc = "" ] # [ doc = " Authorization requires the following" ] # [ doc = " [Google IAM](https://cloud.google.com/iam) permission on the specified" ] # [ doc = " resource parent:" ] # [ doc = "" ] # [ doc = " * `cloudtasks.queues.getIamPolicy`" ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy for a [Queue][google.cloud.tasks.v2beta3.Queue]. Replaces any existing" ] # [ doc = " policy." ] # [ doc = "" ] # [ doc = " Note: The Cloud Console does not check queue-level IAM permissions yet." ] # [ doc = " Project-level permissions are required to use the Cloud Console." ] # [ doc = "" ] # [ doc = " Authorization requires the following" ] # [ doc = " [Google IAM](https://cloud.google.com/iam) permission on the specified" ] # [ doc = " resource parent:" ] # [ doc = "" ] # [ doc = " * `cloudtasks.queues.setIamPolicy`" ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has on a [Queue][google.cloud.tasks.v2beta3.Queue]." ] # [ doc = " If the resource does not exist, this will return an empty set of" ] # [ doc = " permissions, not a [NOT_FOUND][google.rpc.Code.NOT_FOUND] error." ] # [ doc = "" ] # [ doc = " Note: This operation is designed to be used for building permission-aware" ] # [ doc = " UIs and command-line tools, not for authorization checking. This operation" ] # [ doc = " may \"fail open\" without warning." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the tasks in a queue." ] # [ doc = "" ] # [ doc = " By default, only the [BASIC][google.cloud.tasks.v2beta3.Task.View.BASIC] view is retrieved" ] # [ doc = " due to performance considerations;" ] # [ doc = " [response_view][google.cloud.tasks.v2beta3.ListTasksRequest.response_view] controls the" ] # [ doc = " subset of information which is returned." ] # [ doc = "" ] # [ doc = " The tasks may be returned in any order. The ordering may change at any" ] # [ doc = " time." ] pub async fn list_tasks ( & mut self , request : impl tonic :: IntoRequest < super :: ListTasksRequest > , ) -> Result < tonic :: Response < super :: ListTasksResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/ListTasks" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a task." ] pub async fn get_task ( & mut self , request : impl tonic :: IntoRequest < super :: GetTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/GetTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a task and adds it to a queue." ] # [ doc = "" ] # [ doc = " Tasks cannot be updated after creation; there is no UpdateTask command." ] # [ doc = "" ] # [ doc = " * The maximum task size is 100KB." ] pub async fn create_task ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/CreateTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a task." ] # [ doc = "" ] # [ doc = " A task can be deleted if it is scheduled or dispatched. A task" ] # [ doc = " cannot be deleted if it has executed successfully or permanently" ] # [ doc = " failed." ] pub async fn delete_task ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTaskRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/DeleteTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Forces a task to run now." ] # [ doc = "" ] # [ doc = " When this method is called, Cloud Tasks will dispatch the task, even if" ] # [ doc = " the task is already running, the queue has reached its [RateLimits][google.cloud.tasks.v2beta3.RateLimits] or" ] # [ doc = " is [PAUSED][google.cloud.tasks.v2beta3.Queue.State.PAUSED]." ] # [ doc = "" ] # [ doc = " This command is meant to be used for manual debugging. For" ] # [ doc = " example, [RunTask][google.cloud.tasks.v2beta3.CloudTasks.RunTask] can be used to retry a failed" ] # [ doc = " task after a fix has been made or to manually force a task to be" ] # [ doc = " dispatched now." ] # [ doc = "" ] # [ doc = " The dispatched task is returned. That is, the task that is returned" ] # [ doc = " contains the [status][Task.status] after the task is dispatched but" ] # [ doc = " before the task is received by its target." ] # [ doc = "" ] # [ doc = " If Cloud Tasks receives a successful response from the task's" ] # [ doc = " target, then the task will be deleted; otherwise the task's" ] # [ doc = " [schedule_time][google.cloud.tasks.v2beta3.Task.schedule_time] will be reset to the time that" ] # [ doc = " [RunTask][google.cloud.tasks.v2beta3.CloudTasks.RunTask] was called plus the retry delay specified" ] # [ doc = " in the queue's [RetryConfig][google.cloud.tasks.v2beta3.RetryConfig]." ] # [ doc = "" ] # [ doc = " [RunTask][google.cloud.tasks.v2beta3.CloudTasks.RunTask] returns" ] # [ doc = " [NOT_FOUND][google.rpc.Code.NOT_FOUND] when it is called on a" ] # [ doc = " task that has already succeeded or permanently failed." ] pub async fn run_task ( & mut self , request : impl tonic :: IntoRequest < super :: RunTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2beta3.CloudTasks/RunTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudTasksClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudTasksClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudTasksClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/tasks/v2.rs:1206:18975 [INFO] [stdout] | [INFO] [stdout] 1206 | # [ doc = r" Generated client implementations." ] pub mod cloud_tasks_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud Tasks allows developers to manage the execution of background" ] # [ doc = " work in their applications." ] pub struct CloudTasksClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudTasksClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists queues." ] # [ doc = "" ] # [ doc = " Queues are returned in lexicographical order." ] pub async fn list_queues ( & mut self , request : impl tonic :: IntoRequest < super :: ListQueuesRequest > , ) -> Result < tonic :: Response < super :: ListQueuesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/ListQueues" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a queue." ] pub async fn get_queue ( & mut self , request : impl tonic :: IntoRequest < super :: GetQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/GetQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a queue." ] # [ doc = "" ] # [ doc = " Queues created with this method allow tasks to live for a maximum of 31" ] # [ doc = " days. After a task is 31 days old, the task will be deleted regardless of whether" ] # [ doc = " it was dispatched or not." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn create_queue ( & mut self , request : impl tonic :: IntoRequest < super :: CreateQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/CreateQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a queue." ] # [ doc = "" ] # [ doc = " This method creates the queue if it does not exist and updates" ] # [ doc = " the queue if it does exist." ] # [ doc = "" ] # [ doc = " Queues created with this method allow tasks to live for a maximum of 31" ] # [ doc = " days. After a task is 31 days old, the task will be deleted regardless of whether" ] # [ doc = " it was dispatched or not." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn update_queue ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/UpdateQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a queue." ] # [ doc = "" ] # [ doc = " This command will delete the queue even if it has tasks in it." ] # [ doc = "" ] # [ doc = " Note: If you delete a queue, a queue with the same name can't be created" ] # [ doc = " for 7 days." ] # [ doc = "" ] # [ doc = " WARNING: Using this method may have unintended side effects if you are" ] # [ doc = " using an App Engine `queue.yaml` or `queue.xml` file to manage your queues." ] # [ doc = " Read" ] # [ doc = " [Overview of Queue Management and" ] # [ doc = " queue.yaml](https://cloud.google.com/tasks/docs/queue-yaml) before using" ] # [ doc = " this method." ] pub async fn delete_queue ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteQueueRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/DeleteQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Purges a queue by deleting all of its tasks." ] # [ doc = "" ] # [ doc = " All tasks created before this method is called are permanently deleted." ] # [ doc = "" ] # [ doc = " Purge operations can take up to one minute to take effect. Tasks" ] # [ doc = " might be dispatched before the purge takes effect. A purge is irreversible." ] pub async fn purge_queue ( & mut self , request : impl tonic :: IntoRequest < super :: PurgeQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/PurgeQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Pauses the queue." ] # [ doc = "" ] # [ doc = " If a queue is paused then the system will stop dispatching tasks" ] # [ doc = " until the queue is resumed via" ] # [ doc = " [ResumeQueue][google.cloud.tasks.v2.CloudTasks.ResumeQueue]. Tasks can still be added" ] # [ doc = " when the queue is paused. A queue is paused if its" ] # [ doc = " [state][google.cloud.tasks.v2.Queue.state] is [PAUSED][google.cloud.tasks.v2.Queue.State.PAUSED]." ] pub async fn pause_queue ( & mut self , request : impl tonic :: IntoRequest < super :: PauseQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/PauseQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Resume a queue." ] # [ doc = "" ] # [ doc = " This method resumes a queue after it has been" ] # [ doc = " [PAUSED][google.cloud.tasks.v2.Queue.State.PAUSED] or" ] # [ doc = " [DISABLED][google.cloud.tasks.v2.Queue.State.DISABLED]. The state of a queue is stored" ] # [ doc = " in the queue's [state][google.cloud.tasks.v2.Queue.state]; after calling this method it" ] # [ doc = " will be set to [RUNNING][google.cloud.tasks.v2.Queue.State.RUNNING]." ] # [ doc = "" ] # [ doc = " WARNING: Resuming many high-QPS queues at the same time can" ] # [ doc = " lead to target overloading. If you are resuming high-QPS" ] # [ doc = " queues, follow the 500/50/5 pattern described in" ] # [ doc = " [Managing Cloud Tasks Scaling" ] # [ doc = " Risks](https://cloud.google.com/tasks/docs/manage-cloud-task-scaling)." ] pub async fn resume_queue ( & mut self , request : impl tonic :: IntoRequest < super :: ResumeQueueRequest > , ) -> Result < tonic :: Response < super :: Queue > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/ResumeQueue" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a [Queue][google.cloud.tasks.v2.Queue]." ] # [ doc = " Returns an empty policy if the resource exists and does not have a policy" ] # [ doc = " set." ] # [ doc = "" ] # [ doc = " Authorization requires the following" ] # [ doc = " [Google IAM](https://cloud.google.com/iam) permission on the specified" ] # [ doc = " resource parent:" ] # [ doc = "" ] # [ doc = " * `cloudtasks.queues.getIamPolicy`" ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy for a [Queue][google.cloud.tasks.v2.Queue]. Replaces any existing" ] # [ doc = " policy." ] # [ doc = "" ] # [ doc = " Note: The Cloud Console does not check queue-level IAM permissions yet." ] # [ doc = " Project-level permissions are required to use the Cloud Console." ] # [ doc = "" ] # [ doc = " Authorization requires the following" ] # [ doc = " [Google IAM](https://cloud.google.com/iam) permission on the specified" ] # [ doc = " resource parent:" ] # [ doc = "" ] # [ doc = " * `cloudtasks.queues.setIamPolicy`" ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has on a [Queue][google.cloud.tasks.v2.Queue]." ] # [ doc = " If the resource does not exist, this will return an empty set of" ] # [ doc = " permissions, not a [NOT_FOUND][google.rpc.Code.NOT_FOUND] error." ] # [ doc = "" ] # [ doc = " Note: This operation is designed to be used for building permission-aware" ] # [ doc = " UIs and command-line tools, not for authorization checking. This operation" ] # [ doc = " may \"fail open\" without warning." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the tasks in a queue." ] # [ doc = "" ] # [ doc = " By default, only the [BASIC][google.cloud.tasks.v2.Task.View.BASIC] view is retrieved" ] # [ doc = " due to performance considerations;" ] # [ doc = " [response_view][google.cloud.tasks.v2.ListTasksRequest.response_view] controls the" ] # [ doc = " subset of information which is returned." ] # [ doc = "" ] # [ doc = " The tasks may be returned in any order. The ordering may change at any" ] # [ doc = " time." ] pub async fn list_tasks ( & mut self , request : impl tonic :: IntoRequest < super :: ListTasksRequest > , ) -> Result < tonic :: Response < super :: ListTasksResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/ListTasks" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a task." ] pub async fn get_task ( & mut self , request : impl tonic :: IntoRequest < super :: GetTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/GetTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a task and adds it to a queue." ] # [ doc = "" ] # [ doc = " Tasks cannot be updated after creation; there is no UpdateTask command." ] # [ doc = "" ] # [ doc = " * The maximum task size is 100KB." ] pub async fn create_task ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/CreateTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a task." ] # [ doc = "" ] # [ doc = " A task can be deleted if it is scheduled or dispatched. A task" ] # [ doc = " cannot be deleted if it has executed successfully or permanently" ] # [ doc = " failed." ] pub async fn delete_task ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTaskRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/DeleteTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Forces a task to run now." ] # [ doc = "" ] # [ doc = " When this method is called, Cloud Tasks will dispatch the task, even if" ] # [ doc = " the task is already running, the queue has reached its [RateLimits][google.cloud.tasks.v2.RateLimits] or" ] # [ doc = " is [PAUSED][google.cloud.tasks.v2.Queue.State.PAUSED]." ] # [ doc = "" ] # [ doc = " This command is meant to be used for manual debugging. For" ] # [ doc = " example, [RunTask][google.cloud.tasks.v2.CloudTasks.RunTask] can be used to retry a failed" ] # [ doc = " task after a fix has been made or to manually force a task to be" ] # [ doc = " dispatched now." ] # [ doc = "" ] # [ doc = " The dispatched task is returned. That is, the task that is returned" ] # [ doc = " contains the [status][Task.status] after the task is dispatched but" ] # [ doc = " before the task is received by its target." ] # [ doc = "" ] # [ doc = " If Cloud Tasks receives a successful response from the task's" ] # [ doc = " target, then the task will be deleted; otherwise the task's" ] # [ doc = " [schedule_time][google.cloud.tasks.v2.Task.schedule_time] will be reset to the time that" ] # [ doc = " [RunTask][google.cloud.tasks.v2.CloudTasks.RunTask] was called plus the retry delay specified" ] # [ doc = " in the queue's [RetryConfig][google.cloud.tasks.v2.RetryConfig]." ] # [ doc = "" ] # [ doc = " [RunTask][google.cloud.tasks.v2.CloudTasks.RunTask] returns" ] # [ doc = " [NOT_FOUND][google.rpc.Code.NOT_FOUND] when it is called on a" ] # [ doc = " task that has already succeeded or permanently failed." ] pub async fn run_task ( & mut self , request : impl tonic :: IntoRequest < super :: RunTaskRequest > , ) -> Result < tonic :: Response < super :: Task > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.tasks.v2.CloudTasks/RunTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudTasksClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudTasksClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudTasksClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/oslogin/v1beta.rs:90:5837 [INFO] [stdout] | [INFO] [stdout] 90 | # [ doc = r" Generated client implementations." ] pub mod os_login_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud OS Login API" ] # [ doc = "" ] # [ doc = " The Cloud OS Login API allows you to manage users and their associated SSH" ] # [ doc = " public keys for logging into virtual machines on Google Cloud Platform." ] pub struct OsLoginServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > OsLoginServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Deletes a POSIX account." ] pub async fn delete_posix_account ( & mut self , request : impl tonic :: IntoRequest < super :: DeletePosixAccountRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1beta.OsLoginService/DeletePosixAccount" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an SSH public key." ] pub async fn delete_ssh_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSshPublicKeyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1beta.OsLoginService/DeleteSshPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves the profile information used for logging in to a virtual machine" ] # [ doc = " on Google Compute Engine." ] pub async fn get_login_profile ( & mut self , request : impl tonic :: IntoRequest < super :: GetLoginProfileRequest > , ) -> Result < tonic :: Response < super :: LoginProfile > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1beta.OsLoginService/GetLoginProfile" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves an SSH public key." ] pub async fn get_ssh_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: GetSshPublicKeyRequest > , ) -> Result < tonic :: Response < super :: super :: common :: SshPublicKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1beta.OsLoginService/GetSshPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Adds an SSH public key and returns the profile information. Default POSIX" ] # [ doc = " account information is set when no username and UID exist as part of the" ] # [ doc = " login profile." ] pub async fn import_ssh_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: ImportSshPublicKeyRequest > , ) -> Result < tonic :: Response < super :: ImportSshPublicKeyResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1beta.OsLoginService/ImportSshPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an SSH public key and returns the profile information. This method" ] # [ doc = " supports patch semantics." ] pub async fn update_ssh_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateSshPublicKeyRequest > , ) -> Result < tonic :: Response < super :: super :: common :: SshPublicKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1beta.OsLoginService/UpdateSshPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for OsLoginServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for OsLoginServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "OsLoginServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/oslogin/v1.rs:90:5813 [INFO] [stdout] | [INFO] [stdout] 90 | # [ doc = r" Generated client implementations." ] pub mod os_login_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud OS Login API" ] # [ doc = "" ] # [ doc = " The Cloud OS Login API allows you to manage users and their associated SSH" ] # [ doc = " public keys for logging into virtual machines on Google Cloud Platform." ] pub struct OsLoginServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > OsLoginServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Deletes a POSIX account." ] pub async fn delete_posix_account ( & mut self , request : impl tonic :: IntoRequest < super :: DeletePosixAccountRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1.OsLoginService/DeletePosixAccount" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an SSH public key." ] pub async fn delete_ssh_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSshPublicKeyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1.OsLoginService/DeleteSshPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves the profile information used for logging in to a virtual machine" ] # [ doc = " on Google Compute Engine." ] pub async fn get_login_profile ( & mut self , request : impl tonic :: IntoRequest < super :: GetLoginProfileRequest > , ) -> Result < tonic :: Response < super :: LoginProfile > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1.OsLoginService/GetLoginProfile" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves an SSH public key." ] pub async fn get_ssh_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: GetSshPublicKeyRequest > , ) -> Result < tonic :: Response < super :: super :: common :: SshPublicKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1.OsLoginService/GetSshPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Adds an SSH public key and returns the profile information. Default POSIX" ] # [ doc = " account information is set when no username and UID exist as part of the" ] # [ doc = " login profile." ] pub async fn import_ssh_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: ImportSshPublicKeyRequest > , ) -> Result < tonic :: Response < super :: ImportSshPublicKeyResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1.OsLoginService/ImportSshPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an SSH public key and returns the profile information. This method" ] # [ doc = " supports patch semantics." ] pub async fn update_ssh_public_key ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateSshPublicKeyRequest > , ) -> Result < tonic :: Response < super :: super :: common :: SshPublicKey > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.oslogin.v1.OsLoginService/UpdateSshPublicKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for OsLoginServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for OsLoginServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "OsLoginServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/asset/v1.rs:777:8554 [INFO] [stdout] | [INFO] [stdout] 777 | # [ doc = r" Generated client implementations." ] pub mod asset_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Asset service definition." ] pub struct AssetServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AssetServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Exports assets with time and resource types to a given Cloud Storage" ] # [ doc = " location. The output format is newline-delimited JSON." ] # [ doc = " This API implements the" ] # [ doc = " [google.longrunning.Operation][google.longrunning.Operation] API allowing" ] # [ doc = " you to keep track of the export." ] pub async fn export_assets ( & mut self , request : impl tonic :: IntoRequest < super :: ExportAssetsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/ExportAssets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Batch gets the update history of assets that overlap a time window." ] # [ doc = " For RESOURCE content, this API outputs history with asset in both" ] # [ doc = " non-delete or deleted status." ] # [ doc = " For IAM_POLICY content, this API outputs history when the asset and its" ] # [ doc = " attached IAM POLICY both exist. This can create gaps in the output history." ] # [ doc = " If a specified asset does not exist, this API returns an INVALID_ARGUMENT" ] # [ doc = " error." ] pub async fn batch_get_assets_history ( & mut self , request : impl tonic :: IntoRequest < super :: BatchGetAssetsHistoryRequest > , ) -> Result < tonic :: Response < super :: BatchGetAssetsHistoryResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/BatchGetAssetsHistory" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a feed in a parent project/folder/organization to listen to its" ] # [ doc = " asset updates." ] pub async fn create_feed ( & mut self , request : impl tonic :: IntoRequest < super :: CreateFeedRequest > , ) -> Result < tonic :: Response < super :: Feed > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/CreateFeed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets details about an asset feed." ] pub async fn get_feed ( & mut self , request : impl tonic :: IntoRequest < super :: GetFeedRequest > , ) -> Result < tonic :: Response < super :: Feed > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/GetFeed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all asset feeds in a parent project/folder/organization." ] pub async fn list_feeds ( & mut self , request : impl tonic :: IntoRequest < super :: ListFeedsRequest > , ) -> Result < tonic :: Response < super :: ListFeedsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/ListFeeds" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an asset feed configuration." ] pub async fn update_feed ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateFeedRequest > , ) -> Result < tonic :: Response < super :: Feed > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/UpdateFeed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an asset feed." ] pub async fn delete_feed ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteFeedRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/DeleteFeed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Searches all the resources within the given accessible scope (e.g., a" ] # [ doc = " project, a folder or an organization). Callers should have" ] # [ doc = " cloud.assets.SearchAllResources permission upon the requested scope," ] # [ doc = " otherwise the request will be rejected." ] pub async fn search_all_resources ( & mut self , request : impl tonic :: IntoRequest < super :: SearchAllResourcesRequest > , ) -> Result < tonic :: Response < super :: SearchAllResourcesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/SearchAllResources" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Searches all the IAM policies within the given accessible scope (e.g., a" ] # [ doc = " project, a folder or an organization). Callers should have" ] # [ doc = " cloud.assets.SearchAllIamPolicies permission upon the requested scope," ] # [ doc = " otherwise the request will be rejected." ] pub async fn search_all_iam_policies ( & mut self , request : impl tonic :: IntoRequest < super :: SearchAllIamPoliciesRequest > , ) -> Result < tonic :: Response < super :: SearchAllIamPoliciesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1.AssetService/SearchAllIamPolicies" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AssetServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AssetServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AssetServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/asset/v1p4beta1.rs:463:3088 [INFO] [stdout] | [INFO] [stdout] 463 | # [ doc = r" Generated client implementations." ] pub mod asset_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Asset service definition." ] pub struct AssetServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AssetServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Analyzes IAM policies based on the specified request. Returns" ] # [ doc = " a list of [IamPolicyAnalysisResult][google.cloud.asset.v1p4beta1.IamPolicyAnalysisResult] matching the request." ] pub async fn analyze_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeIamPolicyRequest > , ) -> Result < tonic :: Response < super :: AnalyzeIamPolicyResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p4beta1.AssetService/AnalyzeIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports IAM policy analysis based on the specified request. This API" ] # [ doc = " implements the [google.longrunning.Operation][google.longrunning.Operation] API allowing you to keep" ] # [ doc = " track of the export. The metadata contains the request to help callers to" ] # [ doc = " map responses to requests." ] pub async fn export_iam_policy_analysis ( & mut self , request : impl tonic :: IntoRequest < super :: ExportIamPolicyAnalysisRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p4beta1.AssetService/ExportIamPolicyAnalysis" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AssetServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AssetServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AssetServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/asset/v1p1beta1.rs:185:3467 [INFO] [stdout] | [INFO] [stdout] 185 | # [ doc = r" Generated client implementations." ] pub mod asset_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Asset service definition." ] pub struct AssetServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AssetServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Searches all the resources under a given accessible CRM scope" ] # [ doc = " (project/folder/organization). This RPC gives callers" ] # [ doc = " especially admins the ability to search all the resources under a scope," ] # [ doc = " even if they don't have .get permission of all the resources. Callers" ] # [ doc = " should have cloud.assets.SearchAllResources permission on the requested" ] # [ doc = " scope, otherwise it will be rejected." ] pub async fn search_all_resources ( & mut self , request : impl tonic :: IntoRequest < super :: SearchAllResourcesRequest > , ) -> Result < tonic :: Response < super :: SearchAllResourcesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p1beta1.AssetService/SearchAllResources" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Searches all the IAM policies under a given accessible CRM scope" ] # [ doc = " (project/folder/organization). This RPC gives callers" ] # [ doc = " especially admins the ability to search all the IAM policies under a scope," ] # [ doc = " even if they don't have .getIamPolicy permission of all the IAM policies." ] # [ doc = " Callers should have cloud.assets.SearchAllIamPolicies permission on the" ] # [ doc = " requested scope, otherwise it will be rejected." ] pub async fn search_all_iam_policies ( & mut self , request : impl tonic :: IntoRequest < super :: SearchAllIamPoliciesRequest > , ) -> Result < tonic :: Response < super :: SearchAllIamPoliciesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p1beta1.AssetService/SearchAllIamPolicies" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AssetServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AssetServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AssetServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/asset/v1beta1.rs:232:3363 [INFO] [stdout] | [INFO] [stdout] 232 | # [ doc = r" Generated client implementations." ] pub mod asset_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Asset service definition." ] pub struct AssetServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AssetServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Exports assets with time and resource types to a given Cloud Storage" ] # [ doc = " location. The output format is newline-delimited JSON." ] # [ doc = " This API implements the" ] # [ doc = " [google.longrunning.Operation][google.longrunning.Operation] API allowing" ] # [ doc = " you to keep track of the export." ] pub async fn export_assets ( & mut self , request : impl tonic :: IntoRequest < super :: ExportAssetsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1beta1.AssetService/ExportAssets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Batch gets the update history of assets that overlap a time window." ] # [ doc = " For RESOURCE content, this API outputs history with asset in both" ] # [ doc = " non-delete or deleted status." ] # [ doc = " For IAM_POLICY content, this API outputs history when the asset and its" ] # [ doc = " attached IAM POLICY both exist. This can create gaps in the output history." ] # [ doc = " If a specified asset does not exist, this API returns an INVALID_ARGUMENT" ] # [ doc = " error." ] pub async fn batch_get_assets_history ( & mut self , request : impl tonic :: IntoRequest < super :: BatchGetAssetsHistoryRequest > , ) -> Result < tonic :: Response < super :: BatchGetAssetsHistoryResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1beta1.AssetService/BatchGetAssetsHistory" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AssetServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AssetServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AssetServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/asset/v1p2beta1.rs:286:4560 [INFO] [stdout] | [INFO] [stdout] 286 | # [ doc = r" Generated client implementations." ] pub mod asset_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Asset service definition." ] pub struct AssetServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AssetServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a feed in a parent project/folder/organization to listen to its" ] # [ doc = " asset updates." ] pub async fn create_feed ( & mut self , request : impl tonic :: IntoRequest < super :: CreateFeedRequest > , ) -> Result < tonic :: Response < super :: Feed > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p2beta1.AssetService/CreateFeed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets details about an asset feed." ] pub async fn get_feed ( & mut self , request : impl tonic :: IntoRequest < super :: GetFeedRequest > , ) -> Result < tonic :: Response < super :: Feed > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p2beta1.AssetService/GetFeed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all asset feeds in a parent project/folder/organization." ] pub async fn list_feeds ( & mut self , request : impl tonic :: IntoRequest < super :: ListFeedsRequest > , ) -> Result < tonic :: Response < super :: ListFeedsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p2beta1.AssetService/ListFeeds" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an asset feed configuration." ] pub async fn update_feed ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateFeedRequest > , ) -> Result < tonic :: Response < super :: Feed > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p2beta1.AssetService/UpdateFeed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an asset feed." ] pub async fn delete_feed ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteFeedRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.asset.v1p2beta1.AssetService/DeleteFeed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AssetServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AssetServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AssetServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/securitycenter/settings/v1beta1.rs:585:13378 [INFO] [stdout] | [INFO] [stdout] 585 | # [ doc = r" Generated client implementations." ] pub mod security_center_settings_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " ## API Overview" ] # [ doc = "" ] # [ doc = " The SecurityCenterSettingsService is a sub-api of" ] # [ doc = " `securitycenter.googleapis.com`. The service provides methods to manage" ] # [ doc = " Security Center Settings, and Component Settings for GCP organizations," ] # [ doc = " folders, projects, and clusters." ] pub struct SecurityCenterSettingsServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SecurityCenterSettingsServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Retrieves the organizations service account, if it exists, otherwise it" ] # [ doc = " creates the organization service account. This API is idempotent and" ] # [ doc = " will only create a service account once. On subsequent calls it will" ] # [ doc = " return the previously created service account. SHA, SCC and CTD Infra" ] # [ doc = " Automation will use this SA. This SA will not have any permissions when" ] # [ doc = " created. The UI will provision this via IAM or the user will using" ] # [ doc = " their own internal process. This API only creates SAs on the organization." ] # [ doc = " Folders are not supported and projects will use per-project SAs associated" ] # [ doc = " with APIs enabled on a project. This API will be called by the UX" ] # [ doc = " onboarding workflow." ] pub async fn get_service_account ( & mut self , request : impl tonic :: IntoRequest < super :: GetServiceAccountRequest > , ) -> Result < tonic :: Response < super :: ServiceAccount > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/GetServiceAccount" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the Settings." ] pub async fn get_settings ( & mut self , request : impl tonic :: IntoRequest < super :: GetSettingsRequest > , ) -> Result < tonic :: Response < super :: Settings > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/GetSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the Settings." ] pub async fn update_settings ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateSettingsRequest > , ) -> Result < tonic :: Response < super :: Settings > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/UpdateSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Reset the organization, folder or project's settings and return" ] # [ doc = " the settings of just that resource to the default." ] # [ doc = "" ] # [ doc = " Settings are present at the organization, folder, project, and cluster" ] # [ doc = " levels. Using Reset on a sub-organization level will remove that resource's" ] # [ doc = " override and result in the parent's settings being used (eg: if Reset on a" ] # [ doc = " cluster, project settings will be used)." ] # [ doc = "" ] # [ doc = " Using Reset on organization will remove the override that was set and" ] # [ doc = " result in default settings being used." ] pub async fn reset_settings ( & mut self , request : impl tonic :: IntoRequest < super :: ResetSettingsRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/ResetSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a list of settings." ] pub async fn batch_get_settings ( & mut self , request : impl tonic :: IntoRequest < super :: BatchGetSettingsRequest > , ) -> Result < tonic :: Response < super :: BatchGetSettingsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/BatchGetSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " CalculateEffectiveSettings looks up all of the Security Center" ] # [ doc = " Settings resources in the GCP resource hierarchy, and calculates the" ] # [ doc = " effective settings on that resource by applying the following rules:" ] # [ doc = " * Settings provided closer to the target resource take precedence over" ] # [ doc = " those further away (e.g. folder will override organization level" ] # [ doc = " settings)." ] # [ doc = " * Product defaults can be overridden at org, folder, project, and cluster" ] # [ doc = " levels." ] # [ doc = " * Detectors will be filtered out if they belong to a billing tier the" ] # [ doc = " customer" ] # [ doc = " has not configured." ] pub async fn calculate_effective_settings ( & mut self , request : impl tonic :: IntoRequest < super :: CalculateEffectiveSettingsRequest > , ) -> Result < tonic :: Response < super :: Settings > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/CalculateEffectiveSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a list of effective settings." ] pub async fn batch_calculate_effective_settings ( & mut self , request : impl tonic :: IntoRequest < super :: BatchCalculateEffectiveSettingsRequest > , ) -> Result < tonic :: Response < super :: BatchCalculateEffectiveSettingsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/BatchCalculateEffectiveSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the Component Settings." ] pub async fn get_component_settings ( & mut self , request : impl tonic :: IntoRequest < super :: GetComponentSettingsRequest > , ) -> Result < tonic :: Response < super :: ComponentSettings > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/GetComponentSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the Component Settings." ] pub async fn update_component_settings ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateComponentSettingsRequest > , ) -> Result < tonic :: Response < super :: ComponentSettings > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/UpdateComponentSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Reset the organization, folder or project's component settings and return" ] # [ doc = " the settings to the default. Settings are present at the" ] # [ doc = " organization, folder and project levels. Using Reset for a folder or" ] # [ doc = " project will remove the override that was set and result in the" ] # [ doc = " organization-level settings being used." ] pub async fn reset_component_settings ( & mut self , request : impl tonic :: IntoRequest < super :: ResetComponentSettingsRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/ResetComponentSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the Effective Component Settings." ] pub async fn calculate_effective_component_settings ( & mut self , request : impl tonic :: IntoRequest < super :: CalculateEffectiveComponentSettingsRequest > , ) -> Result < tonic :: Response < super :: ComponentSettings > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/CalculateEffectiveComponentSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves an unordered list of available detectors." ] pub async fn list_detectors ( & mut self , request : impl tonic :: IntoRequest < super :: ListDetectorsRequest > , ) -> Result < tonic :: Response < super :: ListDetectorsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/ListDetectors" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves an unordered list of available SCC components." ] pub async fn list_components ( & mut self , request : impl tonic :: IntoRequest < super :: ListComponentsRequest > , ) -> Result < tonic :: Response < super :: ListComponentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.securitycenter.settings.v1beta1.SecurityCenterSettingsService/ListComponents" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SecurityCenterSettingsServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SecurityCenterSettingsServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SecurityCenterSettingsServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/securitycenter/v1.rs:1307:16 [INFO] [stdout] | [INFO] [stdout] 1307 | use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/securitycenter/v1p1beta1.rs:1328:16 [INFO] [stdout] | [INFO] [stdout] 1328 | use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/securitycenter/v1beta1.rs:843:16 [INFO] [stdout] | [INFO] [stdout] 843 | use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/dialogflow/v2.rs:2863:10365 [INFO] [stdout] | [INFO] [stdout] 2863 | # [ doc = r" Generated client implementations." ] pub mod agents_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Agents are best described as Natural Language Understanding (NLU) modules" ] # [ doc = " that transform user requests into actionable data. You can include agents" ] # [ doc = " in your app, product, or service to determine user intent and respond to the" ] # [ doc = " user in a natural way." ] # [ doc = "" ] # [ doc = " After you create an agent, you can add [Intents][google.cloud.dialogflow.v2.Intents], [Contexts][google.cloud.dialogflow.v2.Contexts]," ] # [ doc = " [Entity Types][google.cloud.dialogflow.v2.EntityTypes], [Webhooks][google.cloud.dialogflow.v2.WebhookRequest], and so on to" ] # [ doc = " manage the flow of a conversation and match user input to predefined intents" ] # [ doc = " and actions." ] # [ doc = "" ] # [ doc = " You can create an agent using both Dialogflow Standard Edition and" ] # [ doc = " Dialogflow Enterprise Edition. For details, see" ] # [ doc = " [Dialogflow" ] # [ doc = " Editions](https://cloud.google.com/dialogflow/docs/editions)." ] # [ doc = "" ] # [ doc = " You can save your agent for backup or versioning by exporting the agent by" ] # [ doc = " using the [ExportAgent][google.cloud.dialogflow.v2.Agents.ExportAgent] method. You can import a saved" ] # [ doc = " agent by using the [ImportAgent][google.cloud.dialogflow.v2.Agents.ImportAgent] method." ] # [ doc = "" ] # [ doc = " Dialogflow provides several" ] # [ doc = " [prebuilt" ] # [ doc = " agents](https://cloud.google.com/dialogflow/docs/agents-prebuilt)" ] # [ doc = " for common conversation scenarios such as determining a date and time," ] # [ doc = " converting currency, and so on." ] # [ doc = "" ] # [ doc = " For more information about agents, see the" ] # [ doc = " [Dialogflow" ] # [ doc = " documentation](https://cloud.google.com/dialogflow/docs/agents-overview)." ] pub struct AgentsClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AgentsClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Retrieves the specified agent." ] pub async fn get_agent ( & mut self , request : impl tonic :: IntoRequest < super :: GetAgentRequest > , ) -> Result < tonic :: Response < super :: Agent > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/GetAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates/updates the specified agent." ] pub async fn set_agent ( & mut self , request : impl tonic :: IntoRequest < super :: SetAgentRequest > , ) -> Result < tonic :: Response < super :: Agent > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/SetAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the specified agent." ] pub async fn delete_agent ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAgentRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/DeleteAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the list of agents." ] # [ doc = "" ] # [ doc = " Since there is at most one conversational agent per project, this method is" ] # [ doc = " useful primarily for listing all agents across projects the caller has" ] # [ doc = " access to. One can achieve that with a wildcard project collection id \"-\"." ] # [ doc = " Refer to [List" ] # [ doc = " Sub-Collections](https://cloud.google.com/apis/design/design_patterns#list_sub-collections)." ] pub async fn search_agents ( & mut self , request : impl tonic :: IntoRequest < super :: SearchAgentsRequest > , ) -> Result < tonic :: Response < super :: SearchAgentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/SearchAgents" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Trains the specified agent." ] # [ doc = "" ] # [ doc = " Operation " ] pub async fn train_agent ( & mut self , request : impl tonic :: IntoRequest < super :: TrainAgentRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/TrainAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports the specified agent to a ZIP file." ] # [ doc = "" ] # [ doc = " Operation " ] pub async fn export_agent ( & mut self , request : impl tonic :: IntoRequest < super :: ExportAgentRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/ExportAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Imports the specified agent from a ZIP file." ] # [ doc = "" ] # [ doc = " Uploads new intents and entity types without deleting the existing ones." ] # [ doc = " Intents and entity types with the same name are replaced with the new" ] # [ doc = " versions from ImportAgentRequest." ] # [ doc = "" ] # [ doc = " Operation " ] pub async fn import_agent ( & mut self , request : impl tonic :: IntoRequest < super :: ImportAgentRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/ImportAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Restores the specified agent from a ZIP file." ] # [ doc = "" ] # [ doc = " Replaces the current agent version with a new one. All the intents and" ] # [ doc = " entity types in the older version are deleted." ] # [ doc = "" ] # [ doc = " Operation " ] pub async fn restore_agent ( & mut self , request : impl tonic :: IntoRequest < super :: RestoreAgentRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/RestoreAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets agent validation result. Agent validation is performed during" ] # [ doc = " training time and is updated automatically when training is completed." ] pub async fn get_validation_result ( & mut self , request : impl tonic :: IntoRequest < super :: GetValidationResultRequest > , ) -> Result < tonic :: Response < super :: ValidationResult > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dialogflow.v2.Agents/GetValidationResult" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AgentsClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AgentsClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AgentsClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/dialogflow/v2beta1.rs:3651:16 [INFO] [stdout] | [INFO] [stdout] 3651 | use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/documentai/v1beta2.rs:866:3038 [INFO] [stdout] | [INFO] [stdout] 866 | # [ doc = r" Generated client implementations." ] pub mod document_understanding_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service to parse structured information from unstructured or semi-structured" ] # [ doc = " documents using state-of-the-art Google AI such as natural language," ] # [ doc = " computer vision, and translation." ] pub struct DocumentUnderstandingServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DocumentUnderstandingServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " LRO endpoint to batch process many documents. The output is written" ] # [ doc = " to Cloud Storage as JSON in the [Document] format." ] pub async fn batch_process_documents ( & mut self , request : impl tonic :: IntoRequest < super :: BatchProcessDocumentsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.documentai.v1beta2.DocumentUnderstandingService/BatchProcessDocuments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Processes a single document." ] pub async fn process_document ( & mut self , request : impl tonic :: IntoRequest < super :: ProcessDocumentRequest > , ) -> Result < tonic :: Response < super :: Document > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.documentai.v1beta2.DocumentUnderstandingService/ProcessDocument" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DocumentUnderstandingServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DocumentUnderstandingServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DocumentUnderstandingServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/documentai/v1beta1.rs:753:16 [INFO] [stdout] | [INFO] [stdout] 753 | use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/translation/v3.rs:779:7702 [INFO] [stdout] | [INFO] [stdout] 779 | # [ doc = r" Generated client implementations." ] pub mod translation_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Provides natural language translation operations." ] pub struct TranslationServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > TranslationServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Translates input text and returns translated text." ] pub async fn translate_text ( & mut self , request : impl tonic :: IntoRequest < super :: TranslateTextRequest > , ) -> Result < tonic :: Response < super :: TranslateTextResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3.TranslationService/TranslateText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Detects the language of text within a request." ] pub async fn detect_language ( & mut self , request : impl tonic :: IntoRequest < super :: DetectLanguageRequest > , ) -> Result < tonic :: Response < super :: DetectLanguageResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3.TranslationService/DetectLanguage" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a list of supported languages for translation." ] pub async fn get_supported_languages ( & mut self , request : impl tonic :: IntoRequest < super :: GetSupportedLanguagesRequest > , ) -> Result < tonic :: Response < super :: SupportedLanguages > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3.TranslationService/GetSupportedLanguages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Translates a large volume of text in asynchronous batch mode." ] # [ doc = " This function provides real-time output as the inputs are being processed." ] # [ doc = " If caller cancels a request, the partial results (for an input file, it's" ] # [ doc = " all or nothing) may still be available on the specified output location." ] # [ doc = "" ] # [ doc = " This call returns immediately and you can" ] # [ doc = " use google.longrunning.Operation.name to poll the status of the call." ] pub async fn batch_translate_text ( & mut self , request : impl tonic :: IntoRequest < super :: BatchTranslateTextRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3.TranslationService/BatchTranslateText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a glossary and returns the long-running operation. Returns" ] # [ doc = " NOT_FOUND, if the project doesn't exist." ] pub async fn create_glossary ( & mut self , request : impl tonic :: IntoRequest < super :: CreateGlossaryRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3.TranslationService/CreateGlossary" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists glossaries in a project. Returns NOT_FOUND, if the project doesn't" ] # [ doc = " exist." ] pub async fn list_glossaries ( & mut self , request : impl tonic :: IntoRequest < super :: ListGlossariesRequest > , ) -> Result < tonic :: Response < super :: ListGlossariesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3.TranslationService/ListGlossaries" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a glossary. Returns NOT_FOUND, if the glossary doesn't" ] # [ doc = " exist." ] pub async fn get_glossary ( & mut self , request : impl tonic :: IntoRequest < super :: GetGlossaryRequest > , ) -> Result < tonic :: Response < super :: Glossary > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3.TranslationService/GetGlossary" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a glossary, or cancels glossary construction" ] # [ doc = " if the glossary isn't created yet." ] # [ doc = " Returns NOT_FOUND, if the glossary doesn't exist." ] pub async fn delete_glossary ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteGlossaryRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3.TranslationService/DeleteGlossary" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for TranslationServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for TranslationServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "TranslationServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/translation/v3beta1.rs:766:7742 [INFO] [stdout] | [INFO] [stdout] 766 | # [ doc = r" Generated client implementations." ] pub mod translation_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Provides natural language translation operations." ] pub struct TranslationServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > TranslationServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Translates input text and returns translated text." ] pub async fn translate_text ( & mut self , request : impl tonic :: IntoRequest < super :: TranslateTextRequest > , ) -> Result < tonic :: Response < super :: TranslateTextResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3beta1.TranslationService/TranslateText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Detects the language of text within a request." ] pub async fn detect_language ( & mut self , request : impl tonic :: IntoRequest < super :: DetectLanguageRequest > , ) -> Result < tonic :: Response < super :: DetectLanguageResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3beta1.TranslationService/DetectLanguage" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a list of supported languages for translation." ] pub async fn get_supported_languages ( & mut self , request : impl tonic :: IntoRequest < super :: GetSupportedLanguagesRequest > , ) -> Result < tonic :: Response < super :: SupportedLanguages > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3beta1.TranslationService/GetSupportedLanguages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Translates a large volume of text in asynchronous batch mode." ] # [ doc = " This function provides real-time output as the inputs are being processed." ] # [ doc = " If caller cancels a request, the partial results (for an input file, it's" ] # [ doc = " all or nothing) may still be available on the specified output location." ] # [ doc = "" ] # [ doc = " This call returns immediately and you can" ] # [ doc = " use google.longrunning.Operation.name to poll the status of the call." ] pub async fn batch_translate_text ( & mut self , request : impl tonic :: IntoRequest < super :: BatchTranslateTextRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3beta1.TranslationService/BatchTranslateText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a glossary and returns the long-running operation. Returns" ] # [ doc = " NOT_FOUND, if the project doesn't exist." ] pub async fn create_glossary ( & mut self , request : impl tonic :: IntoRequest < super :: CreateGlossaryRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3beta1.TranslationService/CreateGlossary" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists glossaries in a project. Returns NOT_FOUND, if the project doesn't" ] # [ doc = " exist." ] pub async fn list_glossaries ( & mut self , request : impl tonic :: IntoRequest < super :: ListGlossariesRequest > , ) -> Result < tonic :: Response < super :: ListGlossariesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3beta1.TranslationService/ListGlossaries" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a glossary. Returns NOT_FOUND, if the glossary doesn't" ] # [ doc = " exist." ] pub async fn get_glossary ( & mut self , request : impl tonic :: IntoRequest < super :: GetGlossaryRequest > , ) -> Result < tonic :: Response < super :: Glossary > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3beta1.TranslationService/GetGlossary" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a glossary, or cancels glossary construction" ] # [ doc = " if the glossary isn't created yet." ] # [ doc = " Returns NOT_FOUND, if the glossary doesn't exist." ] pub async fn delete_glossary ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteGlossaryRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.translation.v3beta1.TranslationService/DeleteGlossary" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for TranslationServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for TranslationServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "TranslationServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/redis/v1.rs:416:10024 [INFO] [stdout] | [INFO] [stdout] 416 | # [ doc = r" Generated client implementations." ] pub mod cloud_redis_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Configures and manages Cloud Memorystore for Redis instances" ] # [ doc = "" ] # [ doc = " Google Cloud Memorystore for Redis v1" ] # [ doc = "" ] # [ doc = " The `redis.googleapis.com` service implements the Google Cloud Memorystore" ] # [ doc = " for Redis API and defines the following resource model for managing Redis" ] # [ doc = " instances:" ] # [ doc = " * The service works with a collection of cloud projects, named: `/projects/*`" ] # [ doc = " * Each project has a collection of available locations, named: `/locations/*`" ] # [ doc = " * Each location has a collection of Redis instances, named: `/instances/*`" ] # [ doc = " * As such, Redis instances are resources of the form:" ] # [ doc = " `/projects/{project_id}/locations/{location_id}/instances/{instance_id}`" ] # [ doc = "" ] # [ doc = " Note that location_id must be referring to a GCP `region`; for example:" ] # [ doc = " * `projects/redpepper-1290/locations/us-central1/instances/my-redis`" ] pub struct CloudRedisClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudRedisClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists all Redis instances owned by a project in either the specified" ] # [ doc = " location (region) or all locations." ] # [ doc = "" ] # [ doc = " The location should have the following format:" ] # [ doc = "" ] # [ doc = " * `projects/{project_id}/locations/{location_id}`" ] # [ doc = "" ] # [ doc = " If `location_id` is specified as `-` (wildcard), then all regions" ] # [ doc = " available to the project are queried, and the results are aggregated." ] pub async fn list_instances ( & mut self , request : impl tonic :: IntoRequest < super :: ListInstancesRequest > , ) -> Result < tonic :: Response < super :: ListInstancesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1.CloudRedis/ListInstances" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the details of a specific Redis instance." ] pub async fn get_instance ( & mut self , request : impl tonic :: IntoRequest < super :: GetInstanceRequest > , ) -> Result < tonic :: Response < super :: Instance > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1.CloudRedis/GetInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a Redis instance based on the specified tier and memory size." ] # [ doc = "" ] # [ doc = " By default, the instance is accessible from the project's" ] # [ doc = " [default network](/compute/docs/networks-and-firewalls#networks)." ] # [ doc = "" ] # [ doc = " The creation is executed asynchronously and callers may check the returned" ] # [ doc = " operation to track its progress. Once the operation is completed the Redis" ] # [ doc = " instance will be fully functional. Completed longrunning.Operation will" ] # [ doc = " contain the new instance object in the response field." ] # [ doc = "" ] # [ doc = " The returned operation is automatically deleted after a few hours, so there" ] # [ doc = " is no need to call DeleteOperation." ] pub async fn create_instance ( & mut self , request : impl tonic :: IntoRequest < super :: CreateInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1.CloudRedis/CreateInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the metadata and configuration of a specific Redis instance." ] # [ doc = "" ] # [ doc = " Completed longrunning.Operation will contain the new instance object" ] # [ doc = " in the response field. The returned operation is automatically deleted" ] # [ doc = " after a few hours, so there is no need to call DeleteOperation." ] pub async fn update_instance ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1.CloudRedis/UpdateInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Import a Redis RDB snapshot file from Cloud Storage into a Redis instance." ] # [ doc = "" ] # [ doc = " Redis may stop serving during this operation. Instance state will be" ] # [ doc = " IMPORTING for entire operation. When complete, the instance will contain" ] # [ doc = " only data from the imported file." ] # [ doc = "" ] # [ doc = " The returned operation is automatically deleted after a few hours, so" ] # [ doc = " there is no need to call DeleteOperation." ] pub async fn import_instance ( & mut self , request : impl tonic :: IntoRequest < super :: ImportInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1.CloudRedis/ImportInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Export Redis instance data into a Redis RDB format file in Cloud Storage." ] # [ doc = "" ] # [ doc = " Redis will continue serving during this operation." ] # [ doc = "" ] # [ doc = " The returned operation is automatically deleted after a few hours, so" ] # [ doc = " there is no need to call DeleteOperation." ] pub async fn export_instance ( & mut self , request : impl tonic :: IntoRequest < super :: ExportInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1.CloudRedis/ExportInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Initiates a failover of the master node to current replica node for a" ] # [ doc = " specific STANDARD tier Cloud Memorystore for Redis instance." ] pub async fn failover_instance ( & mut self , request : impl tonic :: IntoRequest < super :: FailoverInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1.CloudRedis/FailoverInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a specific Redis instance. Instance stops serving and data is" ] # [ doc = " deleted." ] pub async fn delete_instance ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1.CloudRedis/DeleteInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudRedisClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudRedisClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudRedisClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/redis/v1beta1.rs:403:10836 [INFO] [stdout] | [INFO] [stdout] 403 | # [ doc = r" Generated client implementations." ] pub mod cloud_redis_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Configures and manages Cloud Memorystore for Redis instances" ] # [ doc = "" ] # [ doc = " Google Cloud Memorystore for Redis v1beta1" ] # [ doc = "" ] # [ doc = " The `redis.googleapis.com` service implements the Google Cloud Memorystore" ] # [ doc = " for Redis API and defines the following resource model for managing Redis" ] # [ doc = " instances:" ] # [ doc = " * The service works with a collection of cloud projects, named: `/projects/*`" ] # [ doc = " * Each project has a collection of available locations, named: `/locations/*`" ] # [ doc = " * Each location has a collection of Redis instances, named: `/instances/*`" ] # [ doc = " * As such, Redis instances are resources of the form:" ] # [ doc = " `/projects/{project_id}/locations/{location_id}/instances/{instance_id}`" ] # [ doc = "" ] # [ doc = " Note that location_id must be refering to a GCP `region`; for example:" ] # [ doc = " * `projects/redpepper-1290/locations/us-central1/instances/my-redis`" ] pub struct CloudRedisClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudRedisClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists all Redis instances owned by a project in either the specified" ] # [ doc = " location (region) or all locations." ] # [ doc = "" ] # [ doc = " The location should have the following format:" ] # [ doc = "" ] # [ doc = " * `projects/{project_id}/locations/{location_id}`" ] # [ doc = "" ] # [ doc = " If `location_id` is specified as `-` (wildcard), then all regions" ] # [ doc = " available to the project are queried, and the results are aggregated." ] pub async fn list_instances ( & mut self , request : impl tonic :: IntoRequest < super :: ListInstancesRequest > , ) -> Result < tonic :: Response < super :: ListInstancesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/ListInstances" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the details of a specific Redis instance." ] pub async fn get_instance ( & mut self , request : impl tonic :: IntoRequest < super :: GetInstanceRequest > , ) -> Result < tonic :: Response < super :: Instance > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/GetInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a Redis instance based on the specified tier and memory size." ] # [ doc = "" ] # [ doc = " By default, the instance is accessible from the project's" ] # [ doc = " [default network](/compute/docs/networks-and-firewalls#networks)." ] # [ doc = "" ] # [ doc = " The creation is executed asynchronously and callers may check the returned" ] # [ doc = " operation to track its progress. Once the operation is completed the Redis" ] # [ doc = " instance will be fully functional. Completed longrunning.Operation will" ] # [ doc = " contain the new instance object in the response field." ] # [ doc = "" ] # [ doc = " The returned operation is automatically deleted after a few hours, so there" ] # [ doc = " is no need to call DeleteOperation." ] pub async fn create_instance ( & mut self , request : impl tonic :: IntoRequest < super :: CreateInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/CreateInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the metadata and configuration of a specific Redis instance." ] # [ doc = "" ] # [ doc = " Completed longrunning.Operation will contain the new instance object" ] # [ doc = " in the response field. The returned operation is automatically deleted" ] # [ doc = " after a few hours, so there is no need to call DeleteOperation." ] pub async fn update_instance ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/UpdateInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Upgrades Redis instance to the newer Redis version specified in the" ] # [ doc = " request." ] pub async fn upgrade_instance ( & mut self , request : impl tonic :: IntoRequest < super :: UpgradeInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/UpgradeInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Import a Redis RDB snapshot file from Cloud Storage into a Redis instance." ] # [ doc = "" ] # [ doc = " Redis may stop serving during this operation. Instance state will be" ] # [ doc = " IMPORTING for entire operation. When complete, the instance will contain" ] # [ doc = " only data from the imported file." ] # [ doc = "" ] # [ doc = " The returned operation is automatically deleted after a few hours, so" ] # [ doc = " there is no need to call DeleteOperation." ] pub async fn import_instance ( & mut self , request : impl tonic :: IntoRequest < super :: ImportInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/ImportInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Export Redis instance data into a Redis RDB format file in Cloud Storage." ] # [ doc = "" ] # [ doc = " Redis will continue serving during this operation." ] # [ doc = "" ] # [ doc = " The returned operation is automatically deleted after a few hours, so" ] # [ doc = " there is no need to call DeleteOperation." ] pub async fn export_instance ( & mut self , request : impl tonic :: IntoRequest < super :: ExportInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/ExportInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Initiates a failover of the master node to current replica node for a" ] # [ doc = " specific STANDARD tier Cloud Memorystore for Redis instance." ] pub async fn failover_instance ( & mut self , request : impl tonic :: IntoRequest < super :: FailoverInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/FailoverInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a specific Redis instance. Instance stops serving and data is" ] # [ doc = " deleted." ] pub async fn delete_instance ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.redis.v1beta1.CloudRedis/DeleteInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudRedisClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudRedisClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudRedisClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/accessapproval/v1.rs:311:9824 [INFO] [stdout] | [INFO] [stdout] 311 | # [ doc = r" Generated client implementations." ] pub mod access_approval_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " This API allows a customer to manage accesses to cloud resources by" ] # [ doc = " Google personnel. It defines the following resource model:" ] # [ doc = "" ] # [ doc = " - The API has a collection of" ] # [ doc = " [ApprovalRequest][google.cloud.accessapproval.v1.ApprovalRequest]" ] # [ doc = " resources, named `approvalRequests/{approval_request_id}`" ] # [ doc = " - The API has top-level settings per Project/Folder/Organization, named" ] # [ doc = " `accessApprovalSettings`" ] # [ doc = "" ] # [ doc = " The service also periodically emails a list of recipients, defined at the" ] # [ doc = " Project/Folder/Organization level in the accessApprovalSettings, when there" ] # [ doc = " is a pending ApprovalRequest for them to act on. The ApprovalRequests can" ] # [ doc = " also optionally be published to a Cloud Pub/Sub topic owned by the customer" ] # [ doc = " (for Beta, the Pub/Sub setup is managed manually)." ] # [ doc = "" ] # [ doc = " ApprovalRequests can be approved or dismissed. Google personel can only" ] # [ doc = " access the indicated resource or resources if the request is approved" ] # [ doc = " (subject to some exclusions:" ] # [ doc = " https://cloud.google.com/access-approval/docs/overview#exclusions)." ] # [ doc = "" ] # [ doc = " Note: Using Access Approval functionality will mean that Google may not be" ] # [ doc = " able to meet the SLAs for your chosen products, as any support response times" ] # [ doc = " may be dramatically increased. As such the SLAs do not apply to any service" ] # [ doc = " disruption to the extent impacted by Customer's use of Access Approval. Do" ] # [ doc = " not enable Access Approval for projects where you may require high service" ] # [ doc = " availability and rapid response by Google Cloud Support." ] # [ doc = "" ] # [ doc = " After a request is approved or dismissed, no further action may be taken on" ] # [ doc = " it. Requests with the requested_expiration in the past or with no activity" ] # [ doc = " for 14 days are considered dismissed. When an approval expires, the request" ] # [ doc = " is considered dismissed." ] # [ doc = "" ] # [ doc = " If a request is not approved or dismissed, we call it pending." ] pub struct AccessApprovalClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AccessApprovalClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists approval requests associated with a project, folder, or organization." ] # [ doc = " Approval requests can be filtered by state (pending, active, dismissed)." ] # [ doc = " The order is reverse chronological." ] pub async fn list_approval_requests ( & mut self , request : impl tonic :: IntoRequest < super :: ListApprovalRequestsMessage > , ) -> Result < tonic :: Response < super :: ListApprovalRequestsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.accessapproval.v1.AccessApproval/ListApprovalRequests" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an approval request. Returns NOT_FOUND if the request does not exist." ] pub async fn get_approval_request ( & mut self , request : impl tonic :: IntoRequest < super :: GetApprovalRequestMessage > , ) -> Result < tonic :: Response < super :: ApprovalRequest > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.accessapproval.v1.AccessApproval/GetApprovalRequest" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Approves a request and returns the updated ApprovalRequest." ] # [ doc = "" ] # [ doc = " Returns NOT_FOUND if the request does not exist. Returns" ] # [ doc = " FAILED_PRECONDITION if the request exists but is not in a pending state." ] pub async fn approve_approval_request ( & mut self , request : impl tonic :: IntoRequest < super :: ApproveApprovalRequestMessage > , ) -> Result < tonic :: Response < super :: ApprovalRequest > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.accessapproval.v1.AccessApproval/ApproveApprovalRequest" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Dismisses a request. Returns the updated ApprovalRequest." ] # [ doc = "" ] # [ doc = " NOTE: This does not deny access to the resource if another request has been" ] # [ doc = " made and approved. It is equivalent in effect to ignoring the request" ] # [ doc = " altogether." ] # [ doc = "" ] # [ doc = " Returns NOT_FOUND if the request does not exist." ] # [ doc = "" ] # [ doc = " Returns FAILED_PRECONDITION if the request exists but is not in a pending" ] # [ doc = " state." ] pub async fn dismiss_approval_request ( & mut self , request : impl tonic :: IntoRequest < super :: DismissApprovalRequestMessage > , ) -> Result < tonic :: Response < super :: ApprovalRequest > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.accessapproval.v1.AccessApproval/DismissApprovalRequest" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the settings associated with a project, folder, or organization." ] pub async fn get_access_approval_settings ( & mut self , request : impl tonic :: IntoRequest < super :: GetAccessApprovalSettingsMessage > , ) -> Result < tonic :: Response < super :: AccessApprovalSettings > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.accessapproval.v1.AccessApproval/GetAccessApprovalSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the settings associated with a project, folder, or organization." ] # [ doc = " Settings to update are determined by the value of field_mask." ] pub async fn update_access_approval_settings ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateAccessApprovalSettingsMessage > , ) -> Result < tonic :: Response < super :: AccessApprovalSettings > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.accessapproval.v1.AccessApproval/UpdateAccessApprovalSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the settings associated with a project, folder, or organization." ] # [ doc = " This will have the effect of disabling Access Approval for the project," ] # [ doc = " folder, or organization, but only if all ancestors also have Access" ] # [ doc = " Approval disabled. If Access Approval is enabled at a higher level of the" ] # [ doc = " hierarchy, then Access Approval will still be enabled at this level as" ] # [ doc = " the settings are inherited." ] pub async fn delete_access_approval_settings ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAccessApprovalSettingsMessage > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.accessapproval.v1.AccessApproval/DeleteAccessApprovalSettings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AccessApprovalClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AccessApprovalClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AccessApprovalClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/secrets/v1beta1.rs:297:14740 [INFO] [stdout] | [INFO] [stdout] 297 | # [ doc = r" Generated client implementations." ] pub mod secret_manager_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Secret Manager Service" ] # [ doc = "" ] # [ doc = " Manages secrets and operations using those secrets. Implements a REST" ] # [ doc = " model with the following objects:" ] # [ doc = "" ] # [ doc = " * [Secret][google.cloud.secrets.v1beta1.Secret]" ] # [ doc = " * [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]" ] pub struct SecretManagerServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SecretManagerServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists [Secrets][google.cloud.secrets.v1beta1.Secret]." ] pub async fn list_secrets ( & mut self , request : impl tonic :: IntoRequest < super :: ListSecretsRequest > , ) -> Result < tonic :: Response < super :: ListSecretsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/ListSecrets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new [Secret][google.cloud.secrets.v1beta1.Secret] containing no [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion]." ] pub async fn create_secret ( & mut self , request : impl tonic :: IntoRequest < super :: CreateSecretRequest > , ) -> Result < tonic :: Response < super :: Secret > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/CreateSecret" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion] containing secret data and attaches" ] # [ doc = " it to an existing [Secret][google.cloud.secrets.v1beta1.Secret]." ] pub async fn add_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: AddSecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/AddSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets metadata for a given [Secret][google.cloud.secrets.v1beta1.Secret]." ] pub async fn get_secret ( & mut self , request : impl tonic :: IntoRequest < super :: GetSecretRequest > , ) -> Result < tonic :: Response < super :: Secret > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/GetSecret" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates metadata of an existing [Secret][google.cloud.secrets.v1beta1.Secret]." ] pub async fn update_secret ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateSecretRequest > , ) -> Result < tonic :: Response < super :: Secret > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/UpdateSecret" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a [Secret][google.cloud.secrets.v1beta1.Secret]." ] pub async fn delete_secret ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSecretRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/DeleteSecret" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion]. This call does not return secret" ] # [ doc = " data." ] pub async fn list_secret_versions ( & mut self , request : impl tonic :: IntoRequest < super :: ListSecretVersionsRequest > , ) -> Result < tonic :: Response < super :: ListSecretVersionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/ListSecretVersions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets metadata for a [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]." ] # [ doc = "" ] # [ doc = " `projects/*/secrets/*/versions/latest` is an alias to the `latest`" ] # [ doc = " [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]." ] pub async fn get_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: GetSecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/GetSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Accesses a [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]. This call returns the secret data." ] # [ doc = "" ] # [ doc = " `projects/*/secrets/*/versions/latest` is an alias to the `latest`" ] # [ doc = " [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]." ] pub async fn access_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: AccessSecretVersionRequest > , ) -> Result < tonic :: Response < super :: AccessSecretVersionResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/AccessSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Disables a [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]." ] # [ doc = "" ] # [ doc = " Sets the [state][google.cloud.secrets.v1beta1.SecretVersion.state] of the [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion] to" ] # [ doc = " [DISABLED][google.cloud.secrets.v1beta1.SecretVersion.State.DISABLED]." ] pub async fn disable_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: DisableSecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/DisableSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Enables a [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]." ] # [ doc = "" ] # [ doc = " Sets the [state][google.cloud.secrets.v1beta1.SecretVersion.state] of the [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion] to" ] # [ doc = " [ENABLED][google.cloud.secrets.v1beta1.SecretVersion.State.ENABLED]." ] pub async fn enable_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: EnableSecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/EnableSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Destroys a [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion]." ] # [ doc = "" ] # [ doc = " Sets the [state][google.cloud.secrets.v1beta1.SecretVersion.state] of the [SecretVersion][google.cloud.secrets.v1beta1.SecretVersion] to" ] # [ doc = " [DESTROYED][google.cloud.secrets.v1beta1.SecretVersion.State.DESTROYED] and irrevocably destroys the" ] # [ doc = " secret data." ] pub async fn destroy_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: DestroySecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/DestroySecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on the specified secret. Replaces any" ] # [ doc = " existing policy." ] # [ doc = "" ] # [ doc = " Permissions on [SecretVersions][google.cloud.secrets.v1beta1.SecretVersion] are enforced according" ] # [ doc = " to the policy set on the associated [Secret][google.cloud.secrets.v1beta1.Secret]." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a secret." ] # [ doc = " Returns empty policy if the secret exists and does not have a policy set." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has for the specified secret." ] # [ doc = " If the secret does not exist, this call returns an empty set of" ] # [ doc = " permissions, not a NOT_FOUND error." ] # [ doc = "" ] # [ doc = " Note: This operation is designed to be used for building permission-aware" ] # [ doc = " UIs and command-line tools, not for authorization checking. This operation" ] # [ doc = " may \"fail open\" without warning." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secrets.v1beta1.SecretManagerService/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SecretManagerServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SecretManagerServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SecretManagerServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/websecurityscanner/v1beta.rs:824:10575 [INFO] [stdout] | [INFO] [stdout] 824 | # [ doc = r" Generated client implementations." ] pub mod web_security_scanner_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud Web Security Scanner Service identifies security vulnerabilities in web" ] # [ doc = " applications hosted on Google Cloud Platform. It crawls your application, and" ] # [ doc = " attempts to exercise as many user inputs and event handlers as possible." ] pub struct WebSecurityScannerClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > WebSecurityScannerClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new ScanConfig." ] pub async fn create_scan_config ( & mut self , request : impl tonic :: IntoRequest < super :: CreateScanConfigRequest > , ) -> Result < tonic :: Response < super :: ScanConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/CreateScanConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an existing ScanConfig and its child resources." ] pub async fn delete_scan_config ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteScanConfigRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/DeleteScanConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a ScanConfig." ] pub async fn get_scan_config ( & mut self , request : impl tonic :: IntoRequest < super :: GetScanConfigRequest > , ) -> Result < tonic :: Response < super :: ScanConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/GetScanConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists ScanConfigs under a given project." ] pub async fn list_scan_configs ( & mut self , request : impl tonic :: IntoRequest < super :: ListScanConfigsRequest > , ) -> Result < tonic :: Response < super :: ListScanConfigsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/ListScanConfigs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a ScanConfig. This method support partial update of a ScanConfig." ] pub async fn update_scan_config ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateScanConfigRequest > , ) -> Result < tonic :: Response < super :: ScanConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/UpdateScanConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Start a ScanRun according to the given ScanConfig." ] pub async fn start_scan_run ( & mut self , request : impl tonic :: IntoRequest < super :: StartScanRunRequest > , ) -> Result < tonic :: Response < super :: ScanRun > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/StartScanRun" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a ScanRun." ] pub async fn get_scan_run ( & mut self , request : impl tonic :: IntoRequest < super :: GetScanRunRequest > , ) -> Result < tonic :: Response < super :: ScanRun > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/GetScanRun" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists ScanRuns under a given ScanConfig, in descending order of ScanRun" ] # [ doc = " stop time." ] pub async fn list_scan_runs ( & mut self , request : impl tonic :: IntoRequest < super :: ListScanRunsRequest > , ) -> Result < tonic :: Response < super :: ListScanRunsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/ListScanRuns" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Stops a ScanRun. The stopped ScanRun is returned." ] pub async fn stop_scan_run ( & mut self , request : impl tonic :: IntoRequest < super :: StopScanRunRequest > , ) -> Result < tonic :: Response < super :: ScanRun > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/StopScanRun" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List CrawledUrls under a given ScanRun." ] pub async fn list_crawled_urls ( & mut self , request : impl tonic :: IntoRequest < super :: ListCrawledUrlsRequest > , ) -> Result < tonic :: Response < super :: ListCrawledUrlsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/ListCrawledUrls" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a Finding." ] pub async fn get_finding ( & mut self , request : impl tonic :: IntoRequest < super :: GetFindingRequest > , ) -> Result < tonic :: Response < super :: Finding > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/GetFinding" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List Findings under a given ScanRun." ] pub async fn list_findings ( & mut self , request : impl tonic :: IntoRequest < super :: ListFindingsRequest > , ) -> Result < tonic :: Response < super :: ListFindingsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/ListFindings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List all FindingTypeStats under a given ScanRun." ] pub async fn list_finding_type_stats ( & mut self , request : impl tonic :: IntoRequest < super :: ListFindingTypeStatsRequest > , ) -> Result < tonic :: Response < super :: ListFindingTypeStatsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1beta.WebSecurityScanner/ListFindingTypeStats" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for WebSecurityScannerClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for WebSecurityScannerClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "WebSecurityScannerClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/websecurityscanner/v1.rs:908:10508 [INFO] [stdout] | [INFO] [stdout] 908 | # [ doc = r" Generated client implementations." ] pub mod web_security_scanner_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Web Security Scanner Service identifies security vulnerabilities in web" ] # [ doc = " applications hosted on Google Cloud. It crawls your application, and" ] # [ doc = " attempts to exercise as many user inputs and event handlers as possible." ] pub struct WebSecurityScannerClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > WebSecurityScannerClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new ScanConfig." ] pub async fn create_scan_config ( & mut self , request : impl tonic :: IntoRequest < super :: CreateScanConfigRequest > , ) -> Result < tonic :: Response < super :: ScanConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/CreateScanConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an existing ScanConfig and its child resources." ] pub async fn delete_scan_config ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteScanConfigRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/DeleteScanConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a ScanConfig." ] pub async fn get_scan_config ( & mut self , request : impl tonic :: IntoRequest < super :: GetScanConfigRequest > , ) -> Result < tonic :: Response < super :: ScanConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/GetScanConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists ScanConfigs under a given project." ] pub async fn list_scan_configs ( & mut self , request : impl tonic :: IntoRequest < super :: ListScanConfigsRequest > , ) -> Result < tonic :: Response < super :: ListScanConfigsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/ListScanConfigs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a ScanConfig. This method support partial update of a ScanConfig." ] pub async fn update_scan_config ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateScanConfigRequest > , ) -> Result < tonic :: Response < super :: ScanConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/UpdateScanConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Start a ScanRun according to the given ScanConfig." ] pub async fn start_scan_run ( & mut self , request : impl tonic :: IntoRequest < super :: StartScanRunRequest > , ) -> Result < tonic :: Response < super :: ScanRun > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/StartScanRun" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a ScanRun." ] pub async fn get_scan_run ( & mut self , request : impl tonic :: IntoRequest < super :: GetScanRunRequest > , ) -> Result < tonic :: Response < super :: ScanRun > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/GetScanRun" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists ScanRuns under a given ScanConfig, in descending order of ScanRun" ] # [ doc = " stop time." ] pub async fn list_scan_runs ( & mut self , request : impl tonic :: IntoRequest < super :: ListScanRunsRequest > , ) -> Result < tonic :: Response < super :: ListScanRunsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/ListScanRuns" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Stops a ScanRun. The stopped ScanRun is returned." ] pub async fn stop_scan_run ( & mut self , request : impl tonic :: IntoRequest < super :: StopScanRunRequest > , ) -> Result < tonic :: Response < super :: ScanRun > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/StopScanRun" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List CrawledUrls under a given ScanRun." ] pub async fn list_crawled_urls ( & mut self , request : impl tonic :: IntoRequest < super :: ListCrawledUrlsRequest > , ) -> Result < tonic :: Response < super :: ListCrawledUrlsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/ListCrawledUrls" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a Finding." ] pub async fn get_finding ( & mut self , request : impl tonic :: IntoRequest < super :: GetFindingRequest > , ) -> Result < tonic :: Response < super :: Finding > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/GetFinding" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List Findings under a given ScanRun." ] pub async fn list_findings ( & mut self , request : impl tonic :: IntoRequest < super :: ListFindingsRequest > , ) -> Result < tonic :: Response < super :: ListFindingsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/ListFindings" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List all FindingTypeStats under a given ScanRun." ] pub async fn list_finding_type_stats ( & mut self , request : impl tonic :: IntoRequest < super :: ListFindingTypeStatsRequest > , ) -> Result < tonic :: Response < super :: ListFindingTypeStatsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.websecurityscanner.v1.WebSecurityScanner/ListFindingTypeStats" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for WebSecurityScannerClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for WebSecurityScannerClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "WebSecurityScannerClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/recaptchaenterprise/v1.rs:340:6247 [INFO] [stdout] | [INFO] [stdout] 340 | # [ doc = r" Generated client implementations." ] pub mod recaptcha_enterprise_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service to determine the likelihood an event is legitimate." ] pub struct RecaptchaEnterpriseServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > RecaptchaEnterpriseServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates an Assessment of the likelihood an event is legitimate." ] pub async fn create_assessment ( & mut self , request : impl tonic :: IntoRequest < super :: CreateAssessmentRequest > , ) -> Result < tonic :: Response < super :: Assessment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseService/CreateAssessment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Annotates a previously created Assessment to provide additional information" ] # [ doc = " on whether the event turned out to be authentic or fradulent." ] pub async fn annotate_assessment ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateAssessmentRequest > , ) -> Result < tonic :: Response < super :: AnnotateAssessmentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseService/AnnotateAssessment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new reCAPTCHA Enterprise key." ] pub async fn create_key ( & mut self , request : impl tonic :: IntoRequest < super :: CreateKeyRequest > , ) -> Result < tonic :: Response < super :: Key > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseService/CreateKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the list of all keys that belong to a project." ] pub async fn list_keys ( & mut self , request : impl tonic :: IntoRequest < super :: ListKeysRequest > , ) -> Result < tonic :: Response < super :: ListKeysResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseService/ListKeys" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the specified key." ] pub async fn get_key ( & mut self , request : impl tonic :: IntoRequest < super :: GetKeyRequest > , ) -> Result < tonic :: Response < super :: Key > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseService/GetKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the specified key." ] pub async fn update_key ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateKeyRequest > , ) -> Result < tonic :: Response < super :: Key > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseService/UpdateKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the specified key." ] pub async fn delete_key ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteKeyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1.RecaptchaEnterpriseService/DeleteKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for RecaptchaEnterpriseServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for RecaptchaEnterpriseServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "RecaptchaEnterpriseServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/recaptchaenterprise/v1beta1.rs:321:6375 [INFO] [stdout] | [INFO] [stdout] 321 | # [ doc = r" Generated client implementations." ] pub mod recaptcha_enterprise_service_v1_beta1_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service to determine the likelihood an event is legitimate." ] pub struct RecaptchaEnterpriseServiceV1Beta1Client < T > { inner : tonic :: client :: Grpc < T > , } impl < T > RecaptchaEnterpriseServiceV1Beta1Client < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates an Assessment of the likelihood an event is legitimate." ] pub async fn create_assessment ( & mut self , request : impl tonic :: IntoRequest < super :: CreateAssessmentRequest > , ) -> Result < tonic :: Response < super :: Assessment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1/CreateAssessment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Annotates a previously created Assessment to provide additional information" ] # [ doc = " on whether the event turned out to be authentic or fradulent." ] pub async fn annotate_assessment ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateAssessmentRequest > , ) -> Result < tonic :: Response < super :: AnnotateAssessmentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1/AnnotateAssessment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new reCAPTCHA Enterprise key." ] pub async fn create_key ( & mut self , request : impl tonic :: IntoRequest < super :: CreateKeyRequest > , ) -> Result < tonic :: Response < super :: Key > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1/CreateKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the list of all keys that belong to a project." ] pub async fn list_keys ( & mut self , request : impl tonic :: IntoRequest < super :: ListKeysRequest > , ) -> Result < tonic :: Response < super :: ListKeysResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1/ListKeys" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the specified key." ] pub async fn get_key ( & mut self , request : impl tonic :: IntoRequest < super :: GetKeyRequest > , ) -> Result < tonic :: Response < super :: Key > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1/GetKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the specified key." ] pub async fn update_key ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateKeyRequest > , ) -> Result < tonic :: Response < super :: Key > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1/UpdateKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the specified key." ] pub async fn delete_key ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteKeyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recaptchaenterprise.v1beta1.RecaptchaEnterpriseServiceV1Beta1/DeleteKey" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for RecaptchaEnterpriseServiceV1Beta1Client < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for RecaptchaEnterpriseServiceV1Beta1Client < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "RecaptchaEnterpriseServiceV1Beta1Client {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/recommendationengine/v1beta1.rs:1130:5833 [INFO] [stdout] | [INFO] [stdout] 1130 | # [ doc = r" Generated client implementations." ] pub mod catalog_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service for ingesting catalog information of the customer's website." ] pub struct CatalogServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CatalogServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a catalog item." ] pub async fn create_catalog_item ( & mut self , request : impl tonic :: IntoRequest < super :: CreateCatalogItemRequest > , ) -> Result < tonic :: Response < super :: CatalogItem > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommendationengine.v1beta1.CatalogService/CreateCatalogItem" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a specific catalog item." ] pub async fn get_catalog_item ( & mut self , request : impl tonic :: IntoRequest < super :: GetCatalogItemRequest > , ) -> Result < tonic :: Response < super :: CatalogItem > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommendationengine.v1beta1.CatalogService/GetCatalogItem" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a list of catalog items." ] pub async fn list_catalog_items ( & mut self , request : impl tonic :: IntoRequest < super :: ListCatalogItemsRequest > , ) -> Result < tonic :: Response < super :: ListCatalogItemsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommendationengine.v1beta1.CatalogService/ListCatalogItems" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a catalog item. Partial updating is supported. Non-existing" ] # [ doc = " items will be created." ] pub async fn update_catalog_item ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateCatalogItemRequest > , ) -> Result < tonic :: Response < super :: CatalogItem > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommendationengine.v1beta1.CatalogService/UpdateCatalogItem" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a catalog item." ] pub async fn delete_catalog_item ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteCatalogItemRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommendationengine.v1beta1.CatalogService/DeleteCatalogItem" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Bulk import of multiple catalog items. Request processing may be" ] # [ doc = " synchronous. No partial updating supported. Non-existing items will be" ] # [ doc = " created." ] # [ doc = "" ] # [ doc = " Operation.response is of type ImportResponse. Note that it is" ] # [ doc = " possible for a subset of the items to be successfully updated." ] pub async fn import_catalog_items ( & mut self , request : impl tonic :: IntoRequest < super :: ImportCatalogItemsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommendationengine.v1beta1.CatalogService/ImportCatalogItems" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CatalogServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CatalogServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CatalogServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/secretmanager/v1.rs:298:14784 [INFO] [stdout] | [INFO] [stdout] 298 | # [ doc = r" Generated client implementations." ] pub mod secret_manager_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Secret Manager Service" ] # [ doc = "" ] # [ doc = " Manages secrets and operations using those secrets. Implements a REST" ] # [ doc = " model with the following objects:" ] # [ doc = "" ] # [ doc = " * [Secret][google.cloud.secretmanager.v1.Secret]" ] # [ doc = " * [SecretVersion][google.cloud.secretmanager.v1.SecretVersion]" ] pub struct SecretManagerServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SecretManagerServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists [Secrets][google.cloud.secretmanager.v1.Secret]." ] pub async fn list_secrets ( & mut self , request : impl tonic :: IntoRequest < super :: ListSecretsRequest > , ) -> Result < tonic :: Response < super :: ListSecretsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/ListSecrets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new [Secret][google.cloud.secretmanager.v1.Secret] containing no [SecretVersions][google.cloud.secretmanager.v1.SecretVersion]." ] pub async fn create_secret ( & mut self , request : impl tonic :: IntoRequest < super :: CreateSecretRequest > , ) -> Result < tonic :: Response < super :: Secret > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/CreateSecret" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new [SecretVersion][google.cloud.secretmanager.v1.SecretVersion] containing secret data and attaches" ] # [ doc = " it to an existing [Secret][google.cloud.secretmanager.v1.Secret]." ] pub async fn add_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: AddSecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/AddSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets metadata for a given [Secret][google.cloud.secretmanager.v1.Secret]." ] pub async fn get_secret ( & mut self , request : impl tonic :: IntoRequest < super :: GetSecretRequest > , ) -> Result < tonic :: Response < super :: Secret > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/GetSecret" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates metadata of an existing [Secret][google.cloud.secretmanager.v1.Secret]." ] pub async fn update_secret ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateSecretRequest > , ) -> Result < tonic :: Response < super :: Secret > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/UpdateSecret" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a [Secret][google.cloud.secretmanager.v1.Secret]." ] pub async fn delete_secret ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSecretRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/DeleteSecret" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists [SecretVersions][google.cloud.secretmanager.v1.SecretVersion]. This call does not return secret" ] # [ doc = " data." ] pub async fn list_secret_versions ( & mut self , request : impl tonic :: IntoRequest < super :: ListSecretVersionsRequest > , ) -> Result < tonic :: Response < super :: ListSecretVersionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/ListSecretVersions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets metadata for a [SecretVersion][google.cloud.secretmanager.v1.SecretVersion]." ] # [ doc = "" ] # [ doc = " `projects/*/secrets/*/versions/latest` is an alias to the `latest`" ] # [ doc = " [SecretVersion][google.cloud.secretmanager.v1.SecretVersion]." ] pub async fn get_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: GetSecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/GetSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Accesses a [SecretVersion][google.cloud.secretmanager.v1.SecretVersion]. This call returns the secret data." ] # [ doc = "" ] # [ doc = " `projects/*/secrets/*/versions/latest` is an alias to the `latest`" ] # [ doc = " [SecretVersion][google.cloud.secretmanager.v1.SecretVersion]." ] pub async fn access_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: AccessSecretVersionRequest > , ) -> Result < tonic :: Response < super :: AccessSecretVersionResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/AccessSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Disables a [SecretVersion][google.cloud.secretmanager.v1.SecretVersion]." ] # [ doc = "" ] # [ doc = " Sets the [state][google.cloud.secretmanager.v1.SecretVersion.state] of the [SecretVersion][google.cloud.secretmanager.v1.SecretVersion] to" ] # [ doc = " [DISABLED][google.cloud.secretmanager.v1.SecretVersion.State.DISABLED]." ] pub async fn disable_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: DisableSecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/DisableSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Enables a [SecretVersion][google.cloud.secretmanager.v1.SecretVersion]." ] # [ doc = "" ] # [ doc = " Sets the [state][google.cloud.secretmanager.v1.SecretVersion.state] of the [SecretVersion][google.cloud.secretmanager.v1.SecretVersion] to" ] # [ doc = " [ENABLED][google.cloud.secretmanager.v1.SecretVersion.State.ENABLED]." ] pub async fn enable_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: EnableSecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/EnableSecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Destroys a [SecretVersion][google.cloud.secretmanager.v1.SecretVersion]." ] # [ doc = "" ] # [ doc = " Sets the [state][google.cloud.secretmanager.v1.SecretVersion.state] of the [SecretVersion][google.cloud.secretmanager.v1.SecretVersion] to" ] # [ doc = " [DESTROYED][google.cloud.secretmanager.v1.SecretVersion.State.DESTROYED] and irrevocably destroys the" ] # [ doc = " secret data." ] pub async fn destroy_secret_version ( & mut self , request : impl tonic :: IntoRequest < super :: DestroySecretVersionRequest > , ) -> Result < tonic :: Response < super :: SecretVersion > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/DestroySecretVersion" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on the specified secret. Replaces any" ] # [ doc = " existing policy." ] # [ doc = "" ] # [ doc = " Permissions on [SecretVersions][google.cloud.secretmanager.v1.SecretVersion] are enforced according" ] # [ doc = " to the policy set on the associated [Secret][google.cloud.secretmanager.v1.Secret]." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a secret." ] # [ doc = " Returns empty policy if the secret exists and does not have a policy set." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has for the specified secret." ] # [ doc = " If the secret does not exist, this call returns an empty set of" ] # [ doc = " permissions, not a NOT_FOUND error." ] # [ doc = "" ] # [ doc = " Note: This operation is designed to be used for building permission-aware" ] # [ doc = " UIs and command-line tools, not for authorization checking. This operation" ] # [ doc = " may \"fail open\" without warning." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.secretmanager.v1.SecretManagerService/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SecretManagerServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SecretManagerServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SecretManagerServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/scheduler/v1.rs:650:7991 [INFO] [stdout] | [INFO] [stdout] 650 | # [ doc = r" Generated client implementations." ] pub mod cloud_scheduler_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The Cloud Scheduler API allows external entities to reliably" ] # [ doc = " schedule asynchronous jobs." ] pub struct CloudSchedulerClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudSchedulerClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists jobs." ] pub async fn list_jobs ( & mut self , request : impl tonic :: IntoRequest < super :: ListJobsRequest > , ) -> Result < tonic :: Response < super :: ListJobsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1.CloudScheduler/ListJobs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a job." ] pub async fn get_job ( & mut self , request : impl tonic :: IntoRequest < super :: GetJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1.CloudScheduler/GetJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a job." ] pub async fn create_job ( & mut self , request : impl tonic :: IntoRequest < super :: CreateJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1.CloudScheduler/CreateJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a job." ] # [ doc = "" ] # [ doc = " If successful, the updated [Job][google.cloud.scheduler.v1.Job] is returned. If the job does" ] # [ doc = " not exist, `NOT_FOUND` is returned." ] # [ doc = "" ] # [ doc = " If UpdateJob does not successfully return, it is possible for the" ] # [ doc = " job to be in an [Job.State.UPDATE_FAILED][google.cloud.scheduler.v1.Job.State.UPDATE_FAILED] state. A job in this state may" ] # [ doc = " not be executed. If this happens, retry the UpdateJob request" ] # [ doc = " until a successful response is received." ] pub async fn update_job ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1.CloudScheduler/UpdateJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a job." ] pub async fn delete_job ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteJobRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1.CloudScheduler/DeleteJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Pauses a job." ] # [ doc = "" ] # [ doc = " If a job is paused then the system will stop executing the job" ] # [ doc = " until it is re-enabled via [ResumeJob][google.cloud.scheduler.v1.CloudScheduler.ResumeJob]. The" ] # [ doc = " state of the job is stored in [state][google.cloud.scheduler.v1.Job.state]; if paused it" ] # [ doc = " will be set to [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. A job must be in [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED]" ] # [ doc = " to be paused." ] pub async fn pause_job ( & mut self , request : impl tonic :: IntoRequest < super :: PauseJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1.CloudScheduler/PauseJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Resume a job." ] # [ doc = "" ] # [ doc = " This method reenables a job after it has been [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. The" ] # [ doc = " state of a job is stored in [Job.state][google.cloud.scheduler.v1.Job.state]; after calling this method it" ] # [ doc = " will be set to [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED]. A job must be in" ] # [ doc = " [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED] to be resumed." ] pub async fn resume_job ( & mut self , request : impl tonic :: IntoRequest < super :: ResumeJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1.CloudScheduler/ResumeJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Forces a job to run now." ] # [ doc = "" ] # [ doc = " When this method is called, Cloud Scheduler will dispatch the job, even" ] # [ doc = " if the job is already running." ] pub async fn run_job ( & mut self , request : impl tonic :: IntoRequest < super :: RunJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1.CloudScheduler/RunJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudSchedulerClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudSchedulerClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudSchedulerClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/scheduler/v1beta1.rs:652:8081 [INFO] [stdout] | [INFO] [stdout] 652 | # [ doc = r" Generated client implementations." ] pub mod cloud_scheduler_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The Cloud Scheduler API allows external entities to reliably" ] # [ doc = " schedule asynchronous jobs." ] pub struct CloudSchedulerClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudSchedulerClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists jobs." ] pub async fn list_jobs ( & mut self , request : impl tonic :: IntoRequest < super :: ListJobsRequest > , ) -> Result < tonic :: Response < super :: ListJobsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1beta1.CloudScheduler/ListJobs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a job." ] pub async fn get_job ( & mut self , request : impl tonic :: IntoRequest < super :: GetJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1beta1.CloudScheduler/GetJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a job." ] pub async fn create_job ( & mut self , request : impl tonic :: IntoRequest < super :: CreateJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1beta1.CloudScheduler/CreateJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a job." ] # [ doc = "" ] # [ doc = " If successful, the updated [Job][google.cloud.scheduler.v1beta1.Job] is returned. If the job does" ] # [ doc = " not exist, `NOT_FOUND` is returned." ] # [ doc = "" ] # [ doc = " If UpdateJob does not successfully return, it is possible for the" ] # [ doc = " job to be in an [Job.State.UPDATE_FAILED][google.cloud.scheduler.v1beta1.Job.State.UPDATE_FAILED] state. A job in this state may" ] # [ doc = " not be executed. If this happens, retry the UpdateJob request" ] # [ doc = " until a successful response is received." ] pub async fn update_job ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1beta1.CloudScheduler/UpdateJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a job." ] pub async fn delete_job ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteJobRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1beta1.CloudScheduler/DeleteJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Pauses a job." ] # [ doc = "" ] # [ doc = " If a job is paused then the system will stop executing the job" ] # [ doc = " until it is re-enabled via [ResumeJob][google.cloud.scheduler.v1beta1.CloudScheduler.ResumeJob]. The" ] # [ doc = " state of the job is stored in [state][google.cloud.scheduler.v1beta1.Job.state]; if paused it" ] # [ doc = " will be set to [Job.State.PAUSED][google.cloud.scheduler.v1beta1.Job.State.PAUSED]. A job must be in [Job.State.ENABLED][google.cloud.scheduler.v1beta1.Job.State.ENABLED]" ] # [ doc = " to be paused." ] pub async fn pause_job ( & mut self , request : impl tonic :: IntoRequest < super :: PauseJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1beta1.CloudScheduler/PauseJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Resume a job." ] # [ doc = "" ] # [ doc = " This method reenables a job after it has been [Job.State.PAUSED][google.cloud.scheduler.v1beta1.Job.State.PAUSED]. The" ] # [ doc = " state of a job is stored in [Job.state][google.cloud.scheduler.v1beta1.Job.state]; after calling this method it" ] # [ doc = " will be set to [Job.State.ENABLED][google.cloud.scheduler.v1beta1.Job.State.ENABLED]. A job must be in" ] # [ doc = " [Job.State.PAUSED][google.cloud.scheduler.v1beta1.Job.State.PAUSED] to be resumed." ] pub async fn resume_job ( & mut self , request : impl tonic :: IntoRequest < super :: ResumeJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1beta1.CloudScheduler/ResumeJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Forces a job to run now." ] # [ doc = "" ] # [ doc = " When this method is called, Cloud Scheduler will dispatch the job, even" ] # [ doc = " if the job is already running." ] pub async fn run_job ( & mut self , request : impl tonic :: IntoRequest < super :: RunJobRequest > , ) -> Result < tonic :: Response < super :: Job > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.scheduler.v1beta1.CloudScheduler/RunJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudSchedulerClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudSchedulerClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudSchedulerClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/phishingprotection/v1beta1.rs:16:2599 [INFO] [stdout] | [INFO] [stdout] 16 | # [ doc = r" Generated client implementations." ] pub mod phishing_protection_service_v1_beta1_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service to report phishing URIs." ] pub struct PhishingProtectionServiceV1Beta1Client < T > { inner : tonic :: client :: Grpc < T > , } impl < T > PhishingProtectionServiceV1Beta1Client < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Reports a URI suspected of containing phishing content to be reviewed. Once" ] # [ doc = " the report review is complete, its result can be found in the Cloud" ] # [ doc = " Security Command Center findings dashboard for Phishing Protection. If the" ] # [ doc = " result verifies the existence of malicious phishing content, the site will" ] # [ doc = " be added the to [Google's Social Engineering" ] # [ doc = " lists](https://support.google.com/webmasters/answer/6350487/) in order to" ] # [ doc = " protect users that could get exposed to this threat in the future." ] pub async fn report_phishing ( & mut self , request : impl tonic :: IntoRequest < super :: ReportPhishingRequest > , ) -> Result < tonic :: Response < super :: ReportPhishingResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.phishingprotection.v1beta1.PhishingProtectionServiceV1Beta1/ReportPhishing" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for PhishingProtectionServiceV1Beta1Client < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for PhishingProtectionServiceV1Beta1Client < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "PhishingProtectionServiceV1Beta1Client {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/language/v1.rs:908:6020 [INFO] [stdout] | [INFO] [stdout] 908 | # [ doc = r" Generated client implementations." ] pub mod language_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Provides text analysis operations such as sentiment analysis and entity" ] # [ doc = " recognition." ] pub struct LanguageServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > LanguageServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Analyzes the sentiment of the provided text." ] pub async fn analyze_sentiment ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeSentimentRequest > , ) -> Result < tonic :: Response < super :: AnalyzeSentimentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1.LanguageService/AnalyzeSentiment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Finds named entities (currently proper names and common nouns) in the text" ] # [ doc = " along with entity types, salience, mentions for each entity, and" ] # [ doc = " other properties." ] pub async fn analyze_entities ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeEntitiesRequest > , ) -> Result < tonic :: Response < super :: AnalyzeEntitiesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1.LanguageService/AnalyzeEntities" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Finds entities, similar to [AnalyzeEntities][google.cloud.language.v1.LanguageService.AnalyzeEntities] in the text and analyzes" ] # [ doc = " sentiment associated with each entity and its mentions." ] pub async fn analyze_entity_sentiment ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeEntitySentimentRequest > , ) -> Result < tonic :: Response < super :: AnalyzeEntitySentimentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1.LanguageService/AnalyzeEntitySentiment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Analyzes the syntax of the text and provides sentence boundaries and" ] # [ doc = " tokenization along with part of speech tags, dependency trees, and other" ] # [ doc = " properties." ] pub async fn analyze_syntax ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeSyntaxRequest > , ) -> Result < tonic :: Response < super :: AnalyzeSyntaxResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1.LanguageService/AnalyzeSyntax" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Classifies a document into categories." ] pub async fn classify_text ( & mut self , request : impl tonic :: IntoRequest < super :: ClassifyTextRequest > , ) -> Result < tonic :: Response < super :: ClassifyTextResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1.LanguageService/ClassifyText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " A convenience method that provides all the features that analyzeSentiment," ] # [ doc = " analyzeEntities, and analyzeSyntax provide in one call." ] pub async fn annotate_text ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateTextRequest > , ) -> Result < tonic :: Response < super :: AnnotateTextResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1.LanguageService/AnnotateText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for LanguageServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for LanguageServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "LanguageServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/language/v1beta2.rs:919:6031 [INFO] [stdout] | [INFO] [stdout] 919 | # [ doc = r" Generated client implementations." ] pub mod language_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Provides text analysis operations such as sentiment analysis and entity" ] # [ doc = " recognition." ] pub struct LanguageServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > LanguageServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Analyzes the sentiment of the provided text." ] pub async fn analyze_sentiment ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeSentimentRequest > , ) -> Result < tonic :: Response < super :: AnalyzeSentimentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta2.LanguageService/AnalyzeSentiment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Finds named entities (currently proper names and common nouns) in the text" ] # [ doc = " along with entity types, salience, mentions for each entity, and" ] # [ doc = " other properties." ] pub async fn analyze_entities ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeEntitiesRequest > , ) -> Result < tonic :: Response < super :: AnalyzeEntitiesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta2.LanguageService/AnalyzeEntities" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Finds entities, similar to [AnalyzeEntities][google.cloud.language.v1beta2.LanguageService.AnalyzeEntities] in the text and analyzes" ] # [ doc = " sentiment associated with each entity and its mentions." ] pub async fn analyze_entity_sentiment ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeEntitySentimentRequest > , ) -> Result < tonic :: Response < super :: AnalyzeEntitySentimentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta2.LanguageService/AnalyzeEntitySentiment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Analyzes the syntax of the text and provides sentence boundaries and" ] # [ doc = " tokenization along with part-of-speech tags, dependency trees, and other" ] # [ doc = " properties." ] pub async fn analyze_syntax ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeSyntaxRequest > , ) -> Result < tonic :: Response < super :: AnalyzeSyntaxResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta2.LanguageService/AnalyzeSyntax" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Classifies a document into categories." ] pub async fn classify_text ( & mut self , request : impl tonic :: IntoRequest < super :: ClassifyTextRequest > , ) -> Result < tonic :: Response < super :: ClassifyTextResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta2.LanguageService/ClassifyText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " A convenience method that provides all syntax, sentiment, entity, and" ] # [ doc = " classification features in one call." ] pub async fn annotate_text ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateTextRequest > , ) -> Result < tonic :: Response < super :: AnnotateTextResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta2.LanguageService/AnnotateText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for LanguageServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for LanguageServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "LanguageServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/language/v1beta1.rs:795:4483 [INFO] [stdout] | [INFO] [stdout] 795 | # [ doc = r" Generated client implementations." ] pub mod language_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Provides text analysis operations such as sentiment analysis and entity" ] # [ doc = " recognition." ] pub struct LanguageServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > LanguageServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Analyzes the sentiment of the provided text." ] pub async fn analyze_sentiment ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeSentimentRequest > , ) -> Result < tonic :: Response < super :: AnalyzeSentimentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta1.LanguageService/AnalyzeSentiment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Finds named entities (currently proper names and common nouns) in the text" ] # [ doc = " along with entity types, salience, mentions for each entity, and" ] # [ doc = " other properties." ] pub async fn analyze_entities ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeEntitiesRequest > , ) -> Result < tonic :: Response < super :: AnalyzeEntitiesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta1.LanguageService/AnalyzeEntities" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Analyzes the syntax of the text and provides sentence boundaries and" ] # [ doc = " tokenization along with part of speech tags, dependency trees, and other" ] # [ doc = " properties." ] pub async fn analyze_syntax ( & mut self , request : impl tonic :: IntoRequest < super :: AnalyzeSyntaxRequest > , ) -> Result < tonic :: Response < super :: AnalyzeSyntaxResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta1.LanguageService/AnalyzeSyntax" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " A convenience method that provides all the features that analyzeSentiment," ] # [ doc = " analyzeEntities, and analyzeSyntax provide in one call." ] pub async fn annotate_text ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateTextRequest > , ) -> Result < tonic :: Response < super :: AnnotateTextResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.language.v1beta1.LanguageService/AnnotateText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for LanguageServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for LanguageServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "LanguageServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/connection/v1.rs:144:7894 [INFO] [stdout] | [INFO] [stdout] 144 | # [ doc = r" Generated client implementations." ] pub mod connection_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Manages external data source connections and credentials." ] pub struct ConnectionServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ConnectionServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new connection." ] pub async fn create_connection ( & mut self , request : impl tonic :: IntoRequest < super :: CreateConnectionRequest > , ) -> Result < tonic :: Response < super :: Connection > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1.ConnectionService/CreateConnection" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns specified connection." ] pub async fn get_connection ( & mut self , request : impl tonic :: IntoRequest < super :: GetConnectionRequest > , ) -> Result < tonic :: Response < super :: Connection > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1.ConnectionService/GetConnection" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a list of connections in the given project." ] pub async fn list_connections ( & mut self , request : impl tonic :: IntoRequest < super :: ListConnectionsRequest > , ) -> Result < tonic :: Response < super :: ListConnectionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1.ConnectionService/ListConnections" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the specified connection. For security reasons, also resets" ] # [ doc = " credential if connection properties are in the update field mask." ] pub async fn update_connection ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateConnectionRequest > , ) -> Result < tonic :: Response < super :: Connection > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1.ConnectionService/UpdateConnection" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes connection and associated credential." ] pub async fn delete_connection ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteConnectionRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1.ConnectionService/DeleteConnection" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a resource." ] # [ doc = " Returns an empty policy if the resource exists and does not have a policy" ] # [ doc = " set." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1.ConnectionService/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on the specified resource. Replaces any" ] # [ doc = " existing policy." ] # [ doc = "" ] # [ doc = " Can return Public Errors: NOT_FOUND, INVALID_ARGUMENT and PERMISSION_DENIED" ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1.ConnectionService/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has on the specified resource." ] # [ doc = " If the resource does not exist, this will return an empty set of" ] # [ doc = " permissions, not a NOT_FOUND error." ] # [ doc = "" ] # [ doc = " Note: This operation is designed to be used for building permission-aware" ] # [ doc = " UIs and command-line tools, not for authorization checking. This operation" ] # [ doc = " may \"fail open\" without warning." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1.ConnectionService/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ConnectionServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ConnectionServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ConnectionServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/connection/v1beta1.rs:171:8658 [INFO] [stdout] | [INFO] [stdout] 171 | # [ doc = r" Generated client implementations." ] pub mod connection_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Manages external data source connections and credentials." ] pub struct ConnectionServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ConnectionServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new connection." ] pub async fn create_connection ( & mut self , request : impl tonic :: IntoRequest < super :: CreateConnectionRequest > , ) -> Result < tonic :: Response < super :: Connection > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/CreateConnection" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns specified connection." ] pub async fn get_connection ( & mut self , request : impl tonic :: IntoRequest < super :: GetConnectionRequest > , ) -> Result < tonic :: Response < super :: Connection > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/GetConnection" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a list of connections in the given project." ] pub async fn list_connections ( & mut self , request : impl tonic :: IntoRequest < super :: ListConnectionsRequest > , ) -> Result < tonic :: Response < super :: ListConnectionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/ListConnections" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the specified connection. For security reasons, also resets" ] # [ doc = " credential if connection properties are in the update field mask." ] pub async fn update_connection ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateConnectionRequest > , ) -> Result < tonic :: Response < super :: Connection > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/UpdateConnection" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the credential for the specified connection." ] pub async fn update_connection_credential ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateConnectionCredentialRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/UpdateConnectionCredential" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes connection and associated credential." ] pub async fn delete_connection ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteConnectionRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/DeleteConnection" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a resource." ] # [ doc = " Returns an empty policy if the resource exists and does not have a policy" ] # [ doc = " set." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on the specified resource. Replaces any" ] # [ doc = " existing policy." ] # [ doc = "" ] # [ doc = " Can return Public Errors: NOT_FOUND, INVALID_ARGUMENT and PERMISSION_DENIED" ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has on the specified resource." ] # [ doc = " If the resource does not exist, this will return an empty set of" ] # [ doc = " permissions, not a NOT_FOUND error." ] # [ doc = "" ] # [ doc = " Note: This operation is designed to be used for building permission-aware" ] # [ doc = " UIs and command-line tools, not for authorization checking. This operation" ] # [ doc = " may \"fail open\" without warning." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.connection.v1beta1.ConnectionService/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ConnectionServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ConnectionServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ConnectionServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/reservation/v1.rs:486:22386 [INFO] [stdout] | [INFO] [stdout] 486 | # [ doc = r" Generated client implementations." ] pub mod reservation_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " This API allows users to manage their flat-rate BigQuery reservations." ] # [ doc = "" ] # [ doc = " A reservation provides computational resource guarantees, in the form of" ] # [ doc = " [slots](https://cloud.google.com/bigquery/docs/slots), to users. A slot is a" ] # [ doc = " unit of computational power in BigQuery, and serves as the basic unit of" ] # [ doc = " parallelism. In a scan of a multi-partitioned table, a single slot operates" ] # [ doc = " on a single partition of the table. A reservation resource exists as a child" ] # [ doc = " resource of the admin project and location, e.g.:" ] # [ doc = " `projects/myproject/locations/US/reservations/reservationName`." ] # [ doc = "" ] # [ doc = " A capacity commitment is a way to purchase compute capacity for BigQuery jobs" ] # [ doc = " (in the form of slots) with some committed period of usage. A capacity" ] # [ doc = " commitment resource exists as a child resource of the admin project and" ] # [ doc = " location, e.g.:" ] # [ doc = " `projects/myproject/locations/US/capacityCommitments/id`." ] pub struct ReservationServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ReservationServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new reservation resource." ] pub async fn create_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: CreateReservationRequest > , ) -> Result < tonic :: Response < super :: Reservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/CreateReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all the reservations for the project in the specified location." ] pub async fn list_reservations ( & mut self , request : impl tonic :: IntoRequest < super :: ListReservationsRequest > , ) -> Result < tonic :: Response < super :: ListReservationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/ListReservations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns information about the reservation." ] pub async fn get_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: GetReservationRequest > , ) -> Result < tonic :: Response < super :: Reservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/GetReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a reservation." ] # [ doc = " Returns `google.rpc.Code.FAILED_PRECONDITION` when reservation has" ] # [ doc = " assignments." ] pub async fn delete_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteReservationRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/DeleteReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing reservation resource." ] pub async fn update_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateReservationRequest > , ) -> Result < tonic :: Response < super :: Reservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/UpdateReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new capacity commitment resource." ] pub async fn create_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: CreateCapacityCommitmentRequest > , ) -> Result < tonic :: Response < super :: CapacityCommitment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/CreateCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all the capacity commitments for the admin project." ] pub async fn list_capacity_commitments ( & mut self , request : impl tonic :: IntoRequest < super :: ListCapacityCommitmentsRequest > , ) -> Result < tonic :: Response < super :: ListCapacityCommitmentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/ListCapacityCommitments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns information about the capacity commitment." ] pub async fn get_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: GetCapacityCommitmentRequest > , ) -> Result < tonic :: Response < super :: CapacityCommitment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/GetCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a capacity commitment. Attempting to delete capacity commitment" ] # [ doc = " before its commitment_end_time will fail with the error code" ] # [ doc = " `google.rpc.Code.FAILED_PRECONDITION`." ] pub async fn delete_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteCapacityCommitmentRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/DeleteCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing capacity commitment." ] # [ doc = "" ] # [ doc = " Only `plan` and `renewal_plan` fields can be updated." ] # [ doc = "" ] # [ doc = " Plan can only be changed to a plan of a longer commitment period." ] # [ doc = " Attempting to change to a plan with shorter commitment period will fail" ] # [ doc = " with the error code `google.rpc.Code.FAILED_PRECONDITION`." ] pub async fn update_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateCapacityCommitmentRequest > , ) -> Result < tonic :: Response < super :: CapacityCommitment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/UpdateCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Splits capacity commitment to two commitments of the same plan and" ] # [ doc = " `commitment_end_time`." ] # [ doc = "" ] # [ doc = " A common use case is to enable downgrading commitments." ] # [ doc = "" ] # [ doc = " For example, in order to downgrade from 10000 slots to 8000, you might" ] # [ doc = " split a 10000 capacity commitment into commitments of 2000 and 8000. Then," ] # [ doc = " you would change the plan of the first one to `FLEX` and then delete it." ] pub async fn split_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: SplitCapacityCommitmentRequest > , ) -> Result < tonic :: Response < super :: SplitCapacityCommitmentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/SplitCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Merges capacity commitments of the same plan into a single commitment." ] # [ doc = "" ] # [ doc = " The resulting capacity commitment has the greater commitment_end_time" ] # [ doc = " out of the to-be-merged capacity commitments." ] # [ doc = "" ] # [ doc = " Attempting to merge capacity commitments of different plan will fail" ] # [ doc = " with the error code `google.rpc.Code.FAILED_PRECONDITION`." ] pub async fn merge_capacity_commitments ( & mut self , request : impl tonic :: IntoRequest < super :: MergeCapacityCommitmentsRequest > , ) -> Result < tonic :: Response < super :: CapacityCommitment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/MergeCapacityCommitments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates an assignment object which allows the given project to submit jobs" ] # [ doc = " of a certain type using slots from the specified reservation." ] # [ doc = "" ] # [ doc = " Currently a" ] # [ doc = " resource (project, folder, organization) can only have one assignment per" ] # [ doc = " each (job_type, location) combination, and that reservation will be used" ] # [ doc = " for all jobs of the matching type." ] # [ doc = "" ] # [ doc = " Different assignments can be created on different levels of the" ] # [ doc = " projects, folders or organization hierarchy. During query execution," ] # [ doc = " the assignment is looked up at the project, folder and organization levels" ] # [ doc = " in that order. The first assignment found is applied to the query." ] # [ doc = "" ] # [ doc = " When creating assignments, it does not matter if other assignments exist at" ] # [ doc = " higher levels." ] # [ doc = "" ] # [ doc = " Example:" ] # [ doc = "" ] # [ doc = " * The organization `organizationA` contains two projects, `project1`" ] # [ doc = " and `project2`." ] # [ doc = " * Assignments for all three entities (`organizationA`, `project1`, and" ] # [ doc = " `project2`) could all be created and mapped to the same or different" ] # [ doc = " reservations." ] # [ doc = "" ] # [ doc = " Returns `google.rpc.Code.PERMISSION_DENIED` if user does not have" ] # [ doc = " 'bigquery.admin' permissions on the project using the reservation" ] # [ doc = " and the project that owns this reservation." ] # [ doc = "" ] # [ doc = " Returns `google.rpc.Code.INVALID_ARGUMENT` when location of the assignment" ] # [ doc = " does not match location of the reservation." ] pub async fn create_assignment ( & mut self , request : impl tonic :: IntoRequest < super :: CreateAssignmentRequest > , ) -> Result < tonic :: Response < super :: Assignment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/CreateAssignment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists assignments." ] # [ doc = "" ] # [ doc = " Only explicitly created assignments will be returned." ] # [ doc = "" ] # [ doc = " Example:" ] # [ doc = "" ] # [ doc = " * Organization `organizationA` contains two projects, `project1` and" ] # [ doc = " `project2`." ] # [ doc = " * Reservation `res1` exists and was created previously." ] # [ doc = " * CreateAssignment was used previously to define the following" ] # [ doc = " associations between entities and reservations: ``" ] # [ doc = " and ``" ] # [ doc = "" ] # [ doc = " In this example, ListAssignments will just return the above two assignments" ] # [ doc = " for reservation `res1`, and no expansion/merge will happen." ] # [ doc = "" ] # [ doc = " The wildcard \"-\" can be used for" ] # [ doc = " reservations in the request. In that case all assignments belongs to the" ] # [ doc = " specified project and location will be listed." ] # [ doc = "" ] # [ doc = " **Note** \"-\" cannot be used for projects nor locations." ] pub async fn list_assignments ( & mut self , request : impl tonic :: IntoRequest < super :: ListAssignmentsRequest > , ) -> Result < tonic :: Response < super :: ListAssignmentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/ListAssignments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a assignment. No expansion will happen." ] # [ doc = "" ] # [ doc = " Example:" ] # [ doc = "" ] # [ doc = " * Organization `organizationA` contains two projects, `project1` and" ] # [ doc = " `project2`." ] # [ doc = " * Reservation `res1` exists and was created previously." ] # [ doc = " * CreateAssignment was used previously to define the following" ] # [ doc = " associations between entities and reservations: ``" ] # [ doc = " and ``" ] # [ doc = "" ] # [ doc = " In this example, deletion of the `` assignment won't" ] # [ doc = " affect the other assignment ``. After said deletion," ] # [ doc = " queries from `project1` will still use `res1` while queries from" ] # [ doc = " `project2` will switch to use on-demand mode." ] pub async fn delete_assignment ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAssignmentRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/DeleteAssignment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Looks up assignments for a specified resource for a particular region." ] # [ doc = " If the request is about a project:" ] # [ doc = "" ] # [ doc = " 1. Assignments created on the project will be returned if they exist." ] # [ doc = " 2. Otherwise assignments created on the closest ancestor will be" ] # [ doc = " returned." ] # [ doc = " 3. Assignments for different JobTypes will all be returned." ] # [ doc = "" ] # [ doc = " The same logic applies if the request is about a folder." ] # [ doc = "" ] # [ doc = " If the request is about an organization, then assignments created on the" ] # [ doc = " organization will be returned (organization doesn't have ancestors)." ] # [ doc = "" ] # [ doc = " Comparing to ListAssignments, there are some behavior" ] # [ doc = " differences:" ] # [ doc = "" ] # [ doc = " 1. permission on the assignee will be verified in this API." ] # [ doc = " 2. Hierarchy lookup (project->folder->organization) happens in this API." ] # [ doc = " 3. Parent here is `projects/*/locations/*`, instead of" ] # [ doc = " `projects/*/locations/*reservations/*`." ] # [ doc = "" ] # [ doc = " **Note** \"-\" cannot be used for projects" ] # [ doc = " nor locations." ] pub async fn search_assignments ( & mut self , request : impl tonic :: IntoRequest < super :: SearchAssignmentsRequest > , ) -> Result < tonic :: Response < super :: SearchAssignmentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/SearchAssignments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Moves an assignment under a new reservation." ] # [ doc = "" ] # [ doc = " This differs from removing an existing assignment and recreating a new one" ] # [ doc = " by providing a transactional change that ensures an assignee always has an" ] # [ doc = " associated reservation." ] pub async fn move_assignment ( & mut self , request : impl tonic :: IntoRequest < super :: MoveAssignmentRequest > , ) -> Result < tonic :: Response < super :: Assignment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/MoveAssignment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves a BI reservation." ] pub async fn get_bi_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: GetBiReservationRequest > , ) -> Result < tonic :: Response < super :: BiReservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/GetBiReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a BI reservation." ] # [ doc = "" ] # [ doc = " Only fields specified in the `field_mask` are updated." ] # [ doc = "" ] # [ doc = " A singleton BI reservation always exists with default size 0." ] # [ doc = " In order to reserve BI capacity it needs to be updated to an amount" ] # [ doc = " greater than 0. In order to release BI capacity reservation size" ] # [ doc = " must be set to 0." ] pub async fn update_bi_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateBiReservationRequest > , ) -> Result < tonic :: Response < super :: BiReservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1.ReservationService/UpdateBiReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ReservationServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ReservationServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ReservationServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/reservation/v1beta1.rs:457:19501 [INFO] [stdout] | [INFO] [stdout] 457 | # [ doc = r" Generated client implementations." ] pub mod reservation_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " This API allows users to manage their flat-rate BigQuery reservations." ] # [ doc = "" ] # [ doc = " A reservation provides computational resource guarantees, in the form of" ] # [ doc = " [slots](https://cloud.google.com/bigquery/docs/slots), to users. A slot is a" ] # [ doc = " unit of computational power in BigQuery, and serves as the basic unit of" ] # [ doc = " parallelism. In a scan of a multi-partitioned table, a single slot operates" ] # [ doc = " on a single partition of the table. A reservation resource exists as a child" ] # [ doc = " resource of the admin project and location, e.g.:" ] # [ doc = " projects/myproject/locations/US/reservations/reservationName." ] # [ doc = "" ] # [ doc = " A capacity commitment is a way to purchase compute capacity for BigQuery jobs" ] # [ doc = " (in the form of slots) with some committed period of usage. A capacity" ] # [ doc = " commitment resource exists as a child resource of the admin project and" ] # [ doc = " location, e.g.:" ] # [ doc = " projects/myproject/locations/US/capacityCommitments/id." ] pub struct ReservationServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ReservationServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new reservation resource." ] pub async fn create_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: CreateReservationRequest > , ) -> Result < tonic :: Response < super :: Reservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/CreateReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all the reservations for the project in the specified location." ] pub async fn list_reservations ( & mut self , request : impl tonic :: IntoRequest < super :: ListReservationsRequest > , ) -> Result < tonic :: Response < super :: ListReservationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/ListReservations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns information about the reservation." ] pub async fn get_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: GetReservationRequest > , ) -> Result < tonic :: Response < super :: Reservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/GetReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a reservation." ] # [ doc = " Returns `google.rpc.Code.FAILED_PRECONDITION` when reservation has" ] # [ doc = " assignments." ] pub async fn delete_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteReservationRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/DeleteReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing reservation resource." ] pub async fn update_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateReservationRequest > , ) -> Result < tonic :: Response < super :: Reservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/UpdateReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all the capacity commitments for the admin project." ] pub async fn list_capacity_commitments ( & mut self , request : impl tonic :: IntoRequest < super :: ListCapacityCommitmentsRequest > , ) -> Result < tonic :: Response < super :: ListCapacityCommitmentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/ListCapacityCommitments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns information about the capacity commitment." ] pub async fn get_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: GetCapacityCommitmentRequest > , ) -> Result < tonic :: Response < super :: CapacityCommitment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/GetCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a capacity commitment. Attempting to delete capacity commitment" ] # [ doc = " before its commitment_end_time will fail with the error code" ] # [ doc = " `google.rpc.Code.FAILED_PRECONDITION`." ] pub async fn delete_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteCapacityCommitmentRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/DeleteCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing capacity commitment." ] # [ doc = "" ] # [ doc = " Only renewal_plan field can be updated." ] pub async fn update_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateCapacityCommitmentRequest > , ) -> Result < tonic :: Response < super :: CapacityCommitment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/UpdateCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Splits capacity commitment to two commitments of the same plan and" ] # [ doc = " commitment_end_time. A common use case to do that is to perform a downgrade" ] # [ doc = " e.g., in order to downgrade from 10000 slots to 8000, one might split 10000" ] # [ doc = " capacity commitment to 2000 and 8000, change the plan of the first one to" ] # [ doc = " flex and then delete it." ] pub async fn split_capacity_commitment ( & mut self , request : impl tonic :: IntoRequest < super :: SplitCapacityCommitmentRequest > , ) -> Result < tonic :: Response < super :: SplitCapacityCommitmentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/SplitCapacityCommitment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Merges capacity commitments of the same plan into one. Resulting capacity" ] # [ doc = " commitment has the longer commitment_end_time out of the two. Attempting to" ] # [ doc = " merge capacity commitments of different plan will fail with the error code" ] # [ doc = " `google.rpc.Code.FAILED_PRECONDITION`." ] pub async fn merge_capacity_commitments ( & mut self , request : impl tonic :: IntoRequest < super :: MergeCapacityCommitmentsRequest > , ) -> Result < tonic :: Response < super :: CapacityCommitment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/MergeCapacityCommitments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns `google.rpc.Code.PERMISSION_DENIED` if user does not have" ] # [ doc = " 'bigquery.admin' permissions on the project using the reservation" ] # [ doc = " and the project that owns this reservation." ] # [ doc = " Returns `google.rpc.Code.INVALID_ARGUMENT` when location of the assignment" ] # [ doc = " does not match location of the reservation." ] pub async fn create_assignment ( & mut self , request : impl tonic :: IntoRequest < super :: CreateAssignmentRequest > , ) -> Result < tonic :: Response < super :: Assignment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/CreateAssignment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists assignments." ] # [ doc = " Only explicitly created assignments will be returned. E.g:" ] # [ doc = " organizationA contains project1 and project2. Reservation res1 exists." ] # [ doc = " CreateAssignment was invoked previously and following assignments were" ] # [ doc = " created explicitly:" ] # [ doc = " " ] # [ doc = " " ] # [ doc = " Then this API will just return the above two assignments for reservation" ] # [ doc = " res1, and no expansion/merge will happen. Wildcard \"-\" can be used for" ] # [ doc = " reservations in the request. In that case all assignments belongs to the" ] # [ doc = " specified project and location will be listed. Note" ] # [ doc = " \"-\" cannot be used for projects nor locations." ] pub async fn list_assignments ( & mut self , request : impl tonic :: IntoRequest < super :: ListAssignmentsRequest > , ) -> Result < tonic :: Response < super :: ListAssignmentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/ListAssignments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a assignment. No expansion will happen." ] # [ doc = " E.g:" ] # [ doc = " organizationA contains project1 and project2. Reservation res1 exists." ] # [ doc = " CreateAssignment was invoked previously and following assignments were" ] # [ doc = " created explicitly:" ] # [ doc = " " ] # [ doc = " " ] # [ doc = " Then deletion of won't affect . After" ] # [ doc = " deletion of , queries from project1 will still use" ] # [ doc = " res1, while queries from project2 will use on-demand mode." ] pub async fn delete_assignment ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAssignmentRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/DeleteAssignment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Looks up assignments for a specified resource for a particular region." ] # [ doc = " If the request is about a project:" ] # [ doc = " 1) Assignments created on the project will be returned if they exist." ] # [ doc = " 2) Otherwise assignments created on the closest ancestor will be" ] # [ doc = " returned. 3) Assignments for different JobTypes will all be returned." ] # [ doc = " Same logic applies if the request is about a folder." ] # [ doc = " If the request is about an organization, then assignments created on the" ] # [ doc = " organization will be returned (organization doesn't have ancestors)." ] # [ doc = " Comparing to ListAssignments, there are some behavior" ] # [ doc = " differences:" ] # [ doc = " 1) permission on the assignee will be verified in this API." ] # [ doc = " 2) Hierarchy lookup (project->folder->organization) happens in this API." ] # [ doc = " 3) Parent here is projects/*/locations/*, instead of" ] # [ doc = " projects/*/locations/*reservations/*." ] # [ doc = " Note \"-\" cannot be used for projects" ] # [ doc = " nor locations." ] pub async fn search_assignments ( & mut self , request : impl tonic :: IntoRequest < super :: SearchAssignmentsRequest > , ) -> Result < tonic :: Response < super :: SearchAssignmentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/SearchAssignments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Moves a assignment under a new reservation. Customers can do this by" ] # [ doc = " deleting the existing assignment followed by creating another assignment" ] # [ doc = " under the new reservation, but this method provides a transactional way to" ] # [ doc = " do so, to make sure the assignee always has an associated reservation." ] # [ doc = " Without the method customers might see some queries run on-demand which" ] # [ doc = " might be unexpected." ] pub async fn move_assignment ( & mut self , request : impl tonic :: IntoRequest < super :: MoveAssignmentRequest > , ) -> Result < tonic :: Response < super :: Assignment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/MoveAssignment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves a BI reservation." ] pub async fn get_bi_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: GetBiReservationRequest > , ) -> Result < tonic :: Response < super :: BiReservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/GetBiReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a BI reservation." ] # [ doc = " Only fields specified in the field_mask are updated." ] # [ doc = " Singleton BI reservation always exists with default size 0." ] # [ doc = " In order to reserve BI capacity it needs to be updated to an amount" ] # [ doc = " greater than 0. In order to release BI capacity reservation size" ] # [ doc = " must be set to 0." ] pub async fn update_bi_reservation ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateBiReservationRequest > , ) -> Result < tonic :: Response < super :: BiReservation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.reservation.v1beta1.ReservationService/UpdateBiReservation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ReservationServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ReservationServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ReservationServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/storage/v1.rs:273:5813 [INFO] [stdout] | [INFO] [stdout] 273 | # [ doc = r" Generated client implementations." ] pub mod big_query_read_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " BigQuery Read API." ] # [ doc = "" ] # [ doc = " The Read API can be used to read data from BigQuery." ] pub struct BigQueryReadClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BigQueryReadClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new read session. A read session divides the contents of a" ] # [ doc = " BigQuery table into one or more streams, which can then be used to read" ] # [ doc = " data from the table. The read session also specifies properties of the" ] # [ doc = " data to be read, such as a list of columns or a push-down filter describing" ] # [ doc = " the rows to be returned." ] # [ doc = "" ] # [ doc = " A particular row can be read by at most one stream. When the caller has" ] # [ doc = " reached the end of each stream in the session, then all the data in the" ] # [ doc = " table has been read." ] # [ doc = "" ] # [ doc = " Data is assigned to each stream such that roughly the same number of" ] # [ doc = " rows can be read from each stream. Because the server-side unit for" ] # [ doc = " assigning data is collections of rows, the API does not guarantee that" ] # [ doc = " each stream will return the same number or rows. Additionally, the" ] # [ doc = " limits are enforced based on the number of pre-filtered rows, so some" ] # [ doc = " filters can lead to lopsided assignments." ] # [ doc = "" ] # [ doc = " Read sessions automatically expire 24 hours after they are created and do" ] # [ doc = " not require manual clean-up by the caller." ] pub async fn create_read_session ( & mut self , request : impl tonic :: IntoRequest < super :: CreateReadSessionRequest > , ) -> Result < tonic :: Response < super :: ReadSession > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1.BigQueryRead/CreateReadSession" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Reads rows from the stream in the format prescribed by the ReadSession." ] # [ doc = " Each response contains one or more table rows, up to a maximum of 100 MiB" ] # [ doc = " per response; read requests which attempt to read individual rows larger" ] # [ doc = " than 100 MiB will fail." ] # [ doc = "" ] # [ doc = " Each request also returns a set of stream statistics reflecting the current" ] # [ doc = " state of the stream." ] pub async fn read_rows ( & mut self , request : impl tonic :: IntoRequest < super :: ReadRowsRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: ReadRowsResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1.BigQueryRead/ReadRows" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Splits a given `ReadStream` into two `ReadStream` objects. These" ] # [ doc = " `ReadStream` objects are referred to as the primary and the residual" ] # [ doc = " streams of the split. The original `ReadStream` can still be read from in" ] # [ doc = " the same manner as before. Both of the returned `ReadStream` objects can" ] # [ doc = " also be read from, and the rows returned by both child streams will be" ] # [ doc = " the same as the rows read from the original stream." ] # [ doc = "" ] # [ doc = " Moreover, the two child streams will be allocated back-to-back in the" ] # [ doc = " original `ReadStream`. Concretely, it is guaranteed that for streams" ] # [ doc = " original, primary, and residual, that original[0-j] = primary[0-j] and" ] # [ doc = " original[j-n] = residual[0-m] once the streams have been read to" ] # [ doc = " completion." ] pub async fn split_read_stream ( & mut self , request : impl tonic :: IntoRequest < super :: SplitReadStreamRequest > , ) -> Result < tonic :: Response < super :: SplitReadStreamResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1.BigQueryRead/SplitReadStream" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BigQueryReadClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BigQueryReadClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BigQueryReadClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/storage/v1beta2.rs:290:5828 [INFO] [stdout] | [INFO] [stdout] 290 | # [ doc = r" Generated client implementations." ] pub mod big_query_read_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " BigQuery Read API." ] # [ doc = "" ] # [ doc = " The Read API can be used to read data from BigQuery." ] pub struct BigQueryReadClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BigQueryReadClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new read session. A read session divides the contents of a" ] # [ doc = " BigQuery table into one or more streams, which can then be used to read" ] # [ doc = " data from the table. The read session also specifies properties of the" ] # [ doc = " data to be read, such as a list of columns or a push-down filter describing" ] # [ doc = " the rows to be returned." ] # [ doc = "" ] # [ doc = " A particular row can be read by at most one stream. When the caller has" ] # [ doc = " reached the end of each stream in the session, then all the data in the" ] # [ doc = " table has been read." ] # [ doc = "" ] # [ doc = " Data is assigned to each stream such that roughly the same number of" ] # [ doc = " rows can be read from each stream. Because the server-side unit for" ] # [ doc = " assigning data is collections of rows, the API does not guarantee that" ] # [ doc = " each stream will return the same number or rows. Additionally, the" ] # [ doc = " limits are enforced based on the number of pre-filtered rows, so some" ] # [ doc = " filters can lead to lopsided assignments." ] # [ doc = "" ] # [ doc = " Read sessions automatically expire 24 hours after they are created and do" ] # [ doc = " not require manual clean-up by the caller." ] pub async fn create_read_session ( & mut self , request : impl tonic :: IntoRequest < super :: CreateReadSessionRequest > , ) -> Result < tonic :: Response < super :: ReadSession > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1beta2.BigQueryRead/CreateReadSession" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Reads rows from the stream in the format prescribed by the ReadSession." ] # [ doc = " Each response contains one or more table rows, up to a maximum of 100 MiB" ] # [ doc = " per response; read requests which attempt to read individual rows larger" ] # [ doc = " than 100 MiB will fail." ] # [ doc = "" ] # [ doc = " Each request also returns a set of stream statistics reflecting the current" ] # [ doc = " state of the stream." ] pub async fn read_rows ( & mut self , request : impl tonic :: IntoRequest < super :: ReadRowsRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: ReadRowsResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1beta2.BigQueryRead/ReadRows" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Splits a given `ReadStream` into two `ReadStream` objects. These" ] # [ doc = " `ReadStream` objects are referred to as the primary and the residual" ] # [ doc = " streams of the split. The original `ReadStream` can still be read from in" ] # [ doc = " the same manner as before. Both of the returned `ReadStream` objects can" ] # [ doc = " also be read from, and the rows returned by both child streams will be" ] # [ doc = " the same as the rows read from the original stream." ] # [ doc = "" ] # [ doc = " Moreover, the two child streams will be allocated back-to-back in the" ] # [ doc = " original `ReadStream`. Concretely, it is guaranteed that for streams" ] # [ doc = " original, primary, and residual, that original[0-j] = primary[0-j] and" ] # [ doc = " original[j-n] = residual[0-m] once the streams have been read to" ] # [ doc = " completion." ] pub async fn split_read_stream ( & mut self , request : impl tonic :: IntoRequest < super :: SplitReadStreamRequest > , ) -> Result < tonic :: Response < super :: SplitReadStreamResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1beta2.BigQueryRead/SplitReadStream" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BigQueryReadClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BigQueryReadClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BigQueryReadClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/storage/v1beta1.rs:358:8080 [INFO] [stdout] | [INFO] [stdout] 358 | # [ doc = r" Generated client implementations." ] pub mod big_query_storage_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " BigQuery storage API." ] # [ doc = "" ] # [ doc = " The BigQuery storage API can be used to read data stored in BigQuery." ] pub struct BigQueryStorageClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BigQueryStorageClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new read session. A read session divides the contents of a" ] # [ doc = " BigQuery table into one or more streams, which can then be used to read" ] # [ doc = " data from the table. The read session also specifies properties of the" ] # [ doc = " data to be read, such as a list of columns or a push-down filter describing" ] # [ doc = " the rows to be returned." ] # [ doc = "" ] # [ doc = " A particular row can be read by at most one stream. When the caller has" ] # [ doc = " reached the end of each stream in the session, then all the data in the" ] # [ doc = " table has been read." ] # [ doc = "" ] # [ doc = " Read sessions automatically expire 24 hours after they are created and do" ] # [ doc = " not require manual clean-up by the caller." ] pub async fn create_read_session ( & mut self , request : impl tonic :: IntoRequest < super :: CreateReadSessionRequest > , ) -> Result < tonic :: Response < super :: ReadSession > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1beta1.BigQueryStorage/CreateReadSession" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Reads rows from the table in the format prescribed by the read session." ] # [ doc = " Each response contains one or more table rows, up to a maximum of 10 MiB" ] # [ doc = " per response; read requests which attempt to read individual rows larger" ] # [ doc = " than this will fail." ] # [ doc = "" ] # [ doc = " Each request also returns a set of stream statistics reflecting the" ] # [ doc = " estimated total number of rows in the read stream. This number is computed" ] # [ doc = " based on the total table size and the number of active streams in the read" ] # [ doc = " session, and may change as other streams continue to read data." ] pub async fn read_rows ( & mut self , request : impl tonic :: IntoRequest < super :: ReadRowsRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: ReadRowsResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1beta1.BigQueryStorage/ReadRows" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates additional streams for a ReadSession. This API can be used to" ] # [ doc = " dynamically adjust the parallelism of a batch processing task upwards by" ] # [ doc = " adding additional workers." ] pub async fn batch_create_read_session_streams ( & mut self , request : impl tonic :: IntoRequest < super :: BatchCreateReadSessionStreamsRequest > , ) -> Result < tonic :: Response < super :: BatchCreateReadSessionStreamsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1beta1.BigQueryStorage/BatchCreateReadSessionStreams" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Triggers the graceful termination of a single stream in a ReadSession. This" ] # [ doc = " API can be used to dynamically adjust the parallelism of a batch processing" ] # [ doc = " task downwards without losing data." ] # [ doc = "" ] # [ doc = " This API does not delete the stream -- it remains visible in the" ] # [ doc = " ReadSession, and any data processed by the stream is not released to other" ] # [ doc = " streams. However, no additional data will be assigned to the stream once" ] # [ doc = " this call completes. Callers must continue reading data on the stream until" ] # [ doc = " the end of the stream is reached so that data which has already been" ] # [ doc = " assigned to the stream will be processed." ] # [ doc = "" ] # [ doc = " This method will return an error if there are no other live streams" ] # [ doc = " in the Session, or if SplitReadStream() has been called on the given" ] # [ doc = " Stream." ] pub async fn finalize_stream ( & mut self , request : impl tonic :: IntoRequest < super :: FinalizeStreamRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1beta1.BigQueryStorage/FinalizeStream" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Splits a given read stream into two Streams. These streams are referred to" ] # [ doc = " as the primary and the residual of the split. The original stream can still" ] # [ doc = " be read from in the same manner as before. Both of the returned streams can" ] # [ doc = " also be read from, and the total rows return by both child streams will be" ] # [ doc = " the same as the rows read from the original stream." ] # [ doc = "" ] # [ doc = " Moreover, the two child streams will be allocated back to back in the" ] # [ doc = " original Stream. Concretely, it is guaranteed that for streams Original," ] # [ doc = " Primary, and Residual, that Original[0-j] = Primary[0-j] and" ] # [ doc = " Original[j-n] = Residual[0-m] once the streams have been read to" ] # [ doc = " completion." ] # [ doc = "" ] # [ doc = " This method is guaranteed to be idempotent." ] pub async fn split_read_stream ( & mut self , request : impl tonic :: IntoRequest < super :: SplitReadStreamRequest > , ) -> Result < tonic :: Response < super :: SplitReadStreamResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.storage.v1beta1.BigQueryStorage/SplitReadStream" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BigQueryStorageClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BigQueryStorageClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BigQueryStorageClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/datatransfer/v1.rs:831:12725 [INFO] [stdout] | [INFO] [stdout] 831 | # [ doc = r" Generated client implementations." ] pub mod data_transfer_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The Google BigQuery Data Transfer Service API enables BigQuery users to" ] # [ doc = " configure the transfer of their data from other Google Products into" ] # [ doc = " BigQuery. This service contains methods that are end user exposed. It backs" ] # [ doc = " up the frontend." ] pub struct DataTransferServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DataTransferServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Retrieves a supported data source and returns its settings," ] # [ doc = " which can be used for UI rendering." ] pub async fn get_data_source ( & mut self , request : impl tonic :: IntoRequest < super :: GetDataSourceRequest > , ) -> Result < tonic :: Response < super :: DataSource > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/GetDataSource" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists supported data sources and returns their settings," ] # [ doc = " which can be used for UI rendering." ] pub async fn list_data_sources ( & mut self , request : impl tonic :: IntoRequest < super :: ListDataSourcesRequest > , ) -> Result < tonic :: Response < super :: ListDataSourcesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/ListDataSources" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new data transfer configuration." ] pub async fn create_transfer_config ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTransferConfigRequest > , ) -> Result < tonic :: Response < super :: TransferConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/CreateTransferConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a data transfer configuration." ] # [ doc = " All fields must be set, even if they are not updated." ] pub async fn update_transfer_config ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateTransferConfigRequest > , ) -> Result < tonic :: Response < super :: TransferConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/UpdateTransferConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a data transfer configuration," ] # [ doc = " including any associated transfer runs and logs." ] pub async fn delete_transfer_config ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTransferConfigRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/DeleteTransferConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns information about a data transfer config." ] pub async fn get_transfer_config ( & mut self , request : impl tonic :: IntoRequest < super :: GetTransferConfigRequest > , ) -> Result < tonic :: Response < super :: TransferConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/GetTransferConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns information about all data transfers in the project." ] pub async fn list_transfer_configs ( & mut self , request : impl tonic :: IntoRequest < super :: ListTransferConfigsRequest > , ) -> Result < tonic :: Response < super :: ListTransferConfigsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/ListTransferConfigs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates transfer runs for a time range [start_time, end_time]." ] # [ doc = " For each date - or whatever granularity the data source supports - in the" ] # [ doc = " range, one transfer run is created." ] # [ doc = " Note that runs are created per UTC time in the time range." ] # [ doc = " DEPRECATED: use StartManualTransferRuns instead." ] pub async fn schedule_transfer_runs ( & mut self , request : impl tonic :: IntoRequest < super :: ScheduleTransferRunsRequest > , ) -> Result < tonic :: Response < super :: ScheduleTransferRunsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/ScheduleTransferRuns" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Start manual transfer runs to be executed now with schedule_time equal to" ] # [ doc = " current time. The transfer runs can be created for a time range where the" ] # [ doc = " run_time is between start_time (inclusive) and end_time (exclusive), or for" ] # [ doc = " a specific run_time." ] pub async fn start_manual_transfer_runs ( & mut self , request : impl tonic :: IntoRequest < super :: StartManualTransferRunsRequest > , ) -> Result < tonic :: Response < super :: StartManualTransferRunsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/StartManualTransferRuns" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns information about the particular transfer run." ] pub async fn get_transfer_run ( & mut self , request : impl tonic :: IntoRequest < super :: GetTransferRunRequest > , ) -> Result < tonic :: Response < super :: TransferRun > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/GetTransferRun" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the specified transfer run." ] pub async fn delete_transfer_run ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTransferRunRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/DeleteTransferRun" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns information about running and completed jobs." ] pub async fn list_transfer_runs ( & mut self , request : impl tonic :: IntoRequest < super :: ListTransferRunsRequest > , ) -> Result < tonic :: Response < super :: ListTransferRunsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/ListTransferRuns" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns user facing log messages for the data transfer run." ] pub async fn list_transfer_logs ( & mut self , request : impl tonic :: IntoRequest < super :: ListTransferLogsRequest > , ) -> Result < tonic :: Response < super :: ListTransferLogsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/ListTransferLogs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns true if valid credentials exist for the given data source and" ] # [ doc = " requesting user." ] # [ doc = " Some data sources doesn't support service account, so we need to talk to" ] # [ doc = " them on behalf of the end user. This API just checks whether we have OAuth" ] # [ doc = " token for the particular user, which is a pre-requisite before user can" ] # [ doc = " create a transfer config." ] pub async fn check_valid_creds ( & mut self , request : impl tonic :: IntoRequest < super :: CheckValidCredsRequest > , ) -> Result < tonic :: Response < super :: CheckValidCredsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.datatransfer.v1.DataTransferService/CheckValidCreds" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DataTransferServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DataTransferServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DataTransferServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/bigquery/v2.rs:724:3880 [INFO] [stdout] | [INFO] [stdout] 724 | # [ doc = r" Generated client implementations." ] pub mod model_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; pub struct ModelServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ModelServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Gets the specified model resource by model ID." ] pub async fn get_model ( & mut self , request : impl tonic :: IntoRequest < super :: GetModelRequest > , ) -> Result < tonic :: Response < super :: Model > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.v2.ModelService/GetModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all models in the specified dataset. Requires the READER dataset" ] # [ doc = " role." ] pub async fn list_models ( & mut self , request : impl tonic :: IntoRequest < super :: ListModelsRequest > , ) -> Result < tonic :: Response < super :: ListModelsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.v2.ModelService/ListModels" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Patch specific fields in the specified model." ] pub async fn patch_model ( & mut self , request : impl tonic :: IntoRequest < super :: PatchModelRequest > , ) -> Result < tonic :: Response < super :: Model > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.v2.ModelService/PatchModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the model specified by modelId from the dataset." ] pub async fn delete_model ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteModelRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.bigquery.v2.ModelService/DeleteModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ModelServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ModelServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ModelServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/vision/v1.rs:1970:5732 [INFO] [stdout] | [INFO] [stdout] 1970 | # [ doc = r" Generated client implementations." ] pub mod image_annotator_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that performs Google Cloud Vision API detection tasks over client" ] # [ doc = " images, such as face, landmark, logo, label, and text detection. The" ] # [ doc = " ImageAnnotator service returns detected entities from the images." ] pub struct ImageAnnotatorClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ImageAnnotatorClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Run image detection and annotation for a batch of images." ] pub async fn batch_annotate_images ( & mut self , request : impl tonic :: IntoRequest < super :: BatchAnnotateImagesRequest > , ) -> Result < tonic :: Response < super :: BatchAnnotateImagesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1.ImageAnnotator/BatchAnnotateImages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Service that performs image detection and annotation for a batch of files." ] # [ doc = " Now only \"application/pdf\", \"image/tiff\" and \"image/gif\" are supported." ] # [ doc = "" ] # [ doc = " This service will extract at most 5 (customers can specify which 5 in" ] # [ doc = " AnnotateFileRequest.pages) frames (gif) or pages (pdf or tiff) from each" ] # [ doc = " file provided and perform detection and annotation for each image" ] # [ doc = " extracted." ] pub async fn batch_annotate_files ( & mut self , request : impl tonic :: IntoRequest < super :: BatchAnnotateFilesRequest > , ) -> Result < tonic :: Response < super :: BatchAnnotateFilesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1.ImageAnnotator/BatchAnnotateFiles" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Run asynchronous image detection and annotation for a list of images." ] # [ doc = "" ] # [ doc = " Progress and results can be retrieved through the" ] # [ doc = " `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `OperationMetadata` (metadata)." ] # [ doc = " `Operation.response` contains `AsyncBatchAnnotateImagesResponse` (results)." ] # [ doc = "" ] # [ doc = " This service will write image annotation outputs to json files in customer" ] # [ doc = " GCS bucket, each json file containing BatchAnnotateImagesResponse proto." ] pub async fn async_batch_annotate_images ( & mut self , request : impl tonic :: IntoRequest < super :: AsyncBatchAnnotateImagesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1.ImageAnnotator/AsyncBatchAnnotateImages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Run asynchronous image detection and annotation for a list of generic" ] # [ doc = " files, such as PDF files, which may contain multiple pages and multiple" ] # [ doc = " images per page. Progress and results can be retrieved through the" ] # [ doc = " `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `OperationMetadata` (metadata)." ] # [ doc = " `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results)." ] pub async fn async_batch_annotate_files ( & mut self , request : impl tonic :: IntoRequest < super :: AsyncBatchAnnotateFilesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1.ImageAnnotator/AsyncBatchAnnotateFiles" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ImageAnnotatorClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ImageAnnotatorClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ImageAnnotatorClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/vision/v1p4beta1.rs:1946:5760 [INFO] [stdout] | [INFO] [stdout] 1946 | # [ doc = r" Generated client implementations." ] pub mod image_annotator_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that performs Google Cloud Vision API detection tasks over client" ] # [ doc = " images, such as face, landmark, logo, label, and text detection. The" ] # [ doc = " ImageAnnotator service returns detected entities from the images." ] pub struct ImageAnnotatorClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ImageAnnotatorClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Run image detection and annotation for a batch of images." ] pub async fn batch_annotate_images ( & mut self , request : impl tonic :: IntoRequest < super :: BatchAnnotateImagesRequest > , ) -> Result < tonic :: Response < super :: BatchAnnotateImagesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p4beta1.ImageAnnotator/BatchAnnotateImages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Service that performs image detection and annotation for a batch of files." ] # [ doc = " Now only \"application/pdf\", \"image/tiff\" and \"image/gif\" are supported." ] # [ doc = "" ] # [ doc = " This service will extract at most 5 (customers can specify which 5 in" ] # [ doc = " AnnotateFileRequest.pages) frames (gif) or pages (pdf or tiff) from each" ] # [ doc = " file provided and perform detection and annotation for each image" ] # [ doc = " extracted." ] pub async fn batch_annotate_files ( & mut self , request : impl tonic :: IntoRequest < super :: BatchAnnotateFilesRequest > , ) -> Result < tonic :: Response < super :: BatchAnnotateFilesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p4beta1.ImageAnnotator/BatchAnnotateFiles" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Run asynchronous image detection and annotation for a list of images." ] # [ doc = "" ] # [ doc = " Progress and results can be retrieved through the" ] # [ doc = " `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `OperationMetadata` (metadata)." ] # [ doc = " `Operation.response` contains `AsyncBatchAnnotateImagesResponse` (results)." ] # [ doc = "" ] # [ doc = " This service will write image annotation outputs to json files in customer" ] # [ doc = " GCS bucket, each json file containing BatchAnnotateImagesResponse proto." ] pub async fn async_batch_annotate_images ( & mut self , request : impl tonic :: IntoRequest < super :: AsyncBatchAnnotateImagesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p4beta1.ImageAnnotator/AsyncBatchAnnotateImages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Run asynchronous image detection and annotation for a list of generic" ] # [ doc = " files, such as PDF files, which may contain multiple pages and multiple" ] # [ doc = " images per page. Progress and results can be retrieved through the" ] # [ doc = " `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `OperationMetadata` (metadata)." ] # [ doc = " `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results)." ] pub async fn async_batch_annotate_files ( & mut self , request : impl tonic :: IntoRequest < super :: AsyncBatchAnnotateFilesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p4beta1.ImageAnnotator/AsyncBatchAnnotateFiles" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ImageAnnotatorClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ImageAnnotatorClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ImageAnnotatorClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/vision/v1p1beta1.rs:882:2175 [INFO] [stdout] | [INFO] [stdout] 882 | # [ doc = r" Generated client implementations." ] pub mod image_annotator_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that performs Google Cloud Vision API detection tasks over client" ] # [ doc = " images, such as face, landmark, logo, label, and text detection. The" ] # [ doc = " ImageAnnotator service returns detected entities from the images." ] pub struct ImageAnnotatorClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ImageAnnotatorClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Run image detection and annotation for a batch of images." ] pub async fn batch_annotate_images ( & mut self , request : impl tonic :: IntoRequest < super :: BatchAnnotateImagesRequest > , ) -> Result < tonic :: Response < super :: BatchAnnotateImagesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p1beta1.ImageAnnotator/BatchAnnotateImages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ImageAnnotatorClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ImageAnnotatorClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ImageAnnotatorClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/vision/v1p2beta1.rs:1071:3332 [INFO] [stdout] | [INFO] [stdout] 1071 | # [ doc = r" Generated client implementations." ] pub mod image_annotator_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that performs Google Cloud Vision API detection tasks over client" ] # [ doc = " images, such as face, landmark, logo, label, and text detection. The" ] # [ doc = " ImageAnnotator service returns detected entities from the images." ] pub struct ImageAnnotatorClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ImageAnnotatorClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Run image detection and annotation for a batch of images." ] pub async fn batch_annotate_images ( & mut self , request : impl tonic :: IntoRequest < super :: BatchAnnotateImagesRequest > , ) -> Result < tonic :: Response < super :: BatchAnnotateImagesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p2beta1.ImageAnnotator/BatchAnnotateImages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Run async image detection and annotation for a list of generic files (e.g." ] # [ doc = " PDF) which may contain multiple pages and multiple images per page." ] # [ doc = " Progress and results can be retrieved through the" ] # [ doc = " `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `OperationMetadata` (metadata)." ] # [ doc = " `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results)." ] pub async fn async_batch_annotate_files ( & mut self , request : impl tonic :: IntoRequest < super :: AsyncBatchAnnotateFilesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p2beta1.ImageAnnotator/AsyncBatchAnnotateFiles" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ImageAnnotatorClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ImageAnnotatorClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ImageAnnotatorClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/vision/v1p3beta1.rs:1807:3348 [INFO] [stdout] | [INFO] [stdout] 1807 | # [ doc = r" Generated client implementations." ] pub mod image_annotator_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that performs Google Cloud Vision API detection tasks over client" ] # [ doc = " images, such as face, landmark, logo, label, and text detection. The" ] # [ doc = " ImageAnnotator service returns detected entities from the images." ] pub struct ImageAnnotatorClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ImageAnnotatorClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Run image detection and annotation for a batch of images." ] pub async fn batch_annotate_images ( & mut self , request : impl tonic :: IntoRequest < super :: BatchAnnotateImagesRequest > , ) -> Result < tonic :: Response < super :: BatchAnnotateImagesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p3beta1.ImageAnnotator/BatchAnnotateImages" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Run asynchronous image detection and annotation for a list of generic" ] # [ doc = " files, such as PDF files, which may contain multiple pages and multiple" ] # [ doc = " images per page. Progress and results can be retrieved through the" ] # [ doc = " `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `OperationMetadata` (metadata)." ] # [ doc = " `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results)." ] pub async fn async_batch_annotate_files ( & mut self , request : impl tonic :: IntoRequest < super :: AsyncBatchAnnotateFilesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.vision.v1p3beta1.ImageAnnotator/AsyncBatchAnnotateFiles" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ImageAnnotatorClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ImageAnnotatorClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ImageAnnotatorClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/automl/v1.rs:3110:16772 [INFO] [stdout] | [INFO] [stdout] 3110 | # [ doc = r" Generated client implementations." ] pub mod auto_ml_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " AutoML Server API." ] # [ doc = "" ] # [ doc = " The resource names are assigned by the server." ] # [ doc = " The server never reuses names that it has created after the resources with" ] # [ doc = " those names are deleted." ] # [ doc = "" ] # [ doc = " An ID of a resource is the last element of the item's resource name. For" ] # [ doc = " `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`, then" ] # [ doc = " the id for the item is `{dataset_id}`." ] # [ doc = "" ] # [ doc = " Currently the only supported `location_id` is \"us-central1\"." ] # [ doc = "" ] # [ doc = " On any input that is documented to expect a string parameter in" ] # [ doc = " snake_case or kebab-case, either of those cases is accepted." ] pub struct AutoMlClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AutoMlClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a dataset." ] pub async fn create_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: CreateDatasetRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/CreateDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a dataset." ] pub async fn get_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: GetDatasetRequest > , ) -> Result < tonic :: Response < super :: Dataset > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/GetDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists datasets in a project." ] pub async fn list_datasets ( & mut self , request : impl tonic :: IntoRequest < super :: ListDatasetsRequest > , ) -> Result < tonic :: Response < super :: ListDatasetsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/ListDatasets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a dataset." ] pub async fn update_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateDatasetRequest > , ) -> Result < tonic :: Response < super :: Dataset > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/UpdateDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a dataset and all of its contents." ] # [ doc = " Returns empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes," ] # [ doc = " and `delete_details` in the" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field." ] pub async fn delete_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteDatasetRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/DeleteDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Imports data into a dataset." ] # [ doc = " For Tables this method can only be called on an empty Dataset." ] # [ doc = "" ] # [ doc = " For Tables:" ] # [ doc = " * A" ] # [ doc = " [schema_inference_version][google.cloud.automl.v1.InputConfig.params]" ] # [ doc = " parameter must be explicitly set." ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn import_data ( & mut self , request : impl tonic :: IntoRequest < super :: ImportDataRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/ImportData" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports dataset's data to the provided output location." ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn export_data ( & mut self , request : impl tonic :: IntoRequest < super :: ExportDataRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/ExportData" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an annotation spec." ] pub async fn get_annotation_spec ( & mut self , request : impl tonic :: IntoRequest < super :: GetAnnotationSpecRequest > , ) -> Result < tonic :: Response < super :: AnnotationSpec > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/GetAnnotationSpec" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a model." ] # [ doc = " Returns a Model in the [response][google.longrunning.Operation.response]" ] # [ doc = " field when it completes." ] # [ doc = " When you create a model, several model evaluations are created for it:" ] # [ doc = " a global evaluation, and one evaluation for each annotation spec." ] pub async fn create_model ( & mut self , request : impl tonic :: IntoRequest < super :: CreateModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/CreateModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a model." ] pub async fn get_model ( & mut self , request : impl tonic :: IntoRequest < super :: GetModelRequest > , ) -> Result < tonic :: Response < super :: Model > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/GetModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists models." ] pub async fn list_models ( & mut self , request : impl tonic :: IntoRequest < super :: ListModelsRequest > , ) -> Result < tonic :: Response < super :: ListModelsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/ListModels" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a model." ] # [ doc = " Returns `google.protobuf.Empty` in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes," ] # [ doc = " and `delete_details` in the" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field." ] pub async fn delete_model ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/DeleteModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a model." ] pub async fn update_model ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateModelRequest > , ) -> Result < tonic :: Response < super :: Model > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/UpdateModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deploys a model. If a model is already deployed, deploying it with the" ] # [ doc = " same parameters has no effect. Deploying with different parametrs" ] # [ doc = " (as e.g. changing" ] # [ doc = "" ] # [ doc = " [node_number][google.cloud.automl.v1p1beta.ImageObjectDetectionModelDeploymentMetadata.node_number])" ] # [ doc = " will reset the deployment state without pausing the model's availability." ] # [ doc = "" ] # [ doc = " Only applicable for Text Classification, Image Object Detection , Tables, and Image Segmentation; all other domains manage" ] # [ doc = " deployment automatically." ] # [ doc = "" ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn deploy_model ( & mut self , request : impl tonic :: IntoRequest < super :: DeployModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/DeployModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Undeploys a model. If the model is not deployed this method has no effect." ] # [ doc = "" ] # [ doc = " Only applicable for Text Classification, Image Object Detection and Tables;" ] # [ doc = " all other domains manage deployment automatically." ] # [ doc = "" ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn undeploy_model ( & mut self , request : impl tonic :: IntoRequest < super :: UndeployModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/UndeployModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports a trained, \"export-able\", model to a user specified Google Cloud" ] # [ doc = " Storage location. A model is considered export-able if and only if it has" ] # [ doc = " an export format defined for it in" ] # [ doc = " [ModelExportOutputConfig][google.cloud.automl.v1.ModelExportOutputConfig]." ] # [ doc = "" ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn export_model ( & mut self , request : impl tonic :: IntoRequest < super :: ExportModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/ExportModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a model evaluation." ] pub async fn get_model_evaluation ( & mut self , request : impl tonic :: IntoRequest < super :: GetModelEvaluationRequest > , ) -> Result < tonic :: Response < super :: ModelEvaluation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/GetModelEvaluation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists model evaluations." ] pub async fn list_model_evaluations ( & mut self , request : impl tonic :: IntoRequest < super :: ListModelEvaluationsRequest > , ) -> Result < tonic :: Response < super :: ListModelEvaluationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1.AutoMl/ListModelEvaluations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AutoMlClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AutoMlClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AutoMlClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/automl/v1beta1.rs:3782:21631 [INFO] [stdout] | [INFO] [stdout] 3782 | # [ doc = r" Generated client implementations." ] pub mod auto_ml_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " AutoML Server API." ] # [ doc = "" ] # [ doc = " The resource names are assigned by the server." ] # [ doc = " The server never reuses names that it has created after the resources with" ] # [ doc = " those names are deleted." ] # [ doc = "" ] # [ doc = " An ID of a resource is the last element of the item's resource name. For" ] # [ doc = " `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`, then" ] # [ doc = " the id for the item is `{dataset_id}`." ] # [ doc = "" ] # [ doc = " Currently the only supported `location_id` is \"us-central1\"." ] # [ doc = "" ] # [ doc = " On any input that is documented to expect a string parameter in" ] # [ doc = " snake_case or kebab-case, either of those cases is accepted." ] pub struct AutoMlClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AutoMlClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a dataset." ] pub async fn create_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: CreateDatasetRequest > , ) -> Result < tonic :: Response < super :: Dataset > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/CreateDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a dataset." ] pub async fn get_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: GetDatasetRequest > , ) -> Result < tonic :: Response < super :: Dataset > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/GetDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists datasets in a project." ] pub async fn list_datasets ( & mut self , request : impl tonic :: IntoRequest < super :: ListDatasetsRequest > , ) -> Result < tonic :: Response < super :: ListDatasetsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ListDatasets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a dataset." ] pub async fn update_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateDatasetRequest > , ) -> Result < tonic :: Response < super :: Dataset > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/UpdateDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a dataset and all of its contents." ] # [ doc = " Returns empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes," ] # [ doc = " and `delete_details` in the" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field." ] pub async fn delete_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteDatasetRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/DeleteDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Imports data into a dataset." ] # [ doc = " For Tables this method can only be called on an empty Dataset." ] # [ doc = "" ] # [ doc = " For Tables:" ] # [ doc = " * A" ] # [ doc = " [schema_inference_version][google.cloud.automl.v1beta1.InputConfig.params]" ] # [ doc = " parameter must be explicitly set." ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn import_data ( & mut self , request : impl tonic :: IntoRequest < super :: ImportDataRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ImportData" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports dataset's data to the provided output location." ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn export_data ( & mut self , request : impl tonic :: IntoRequest < super :: ExportDataRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ExportData" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an annotation spec." ] pub async fn get_annotation_spec ( & mut self , request : impl tonic :: IntoRequest < super :: GetAnnotationSpecRequest > , ) -> Result < tonic :: Response < super :: AnnotationSpec > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/GetAnnotationSpec" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a table spec." ] pub async fn get_table_spec ( & mut self , request : impl tonic :: IntoRequest < super :: GetTableSpecRequest > , ) -> Result < tonic :: Response < super :: TableSpec > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/GetTableSpec" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists table specs in a dataset." ] pub async fn list_table_specs ( & mut self , request : impl tonic :: IntoRequest < super :: ListTableSpecsRequest > , ) -> Result < tonic :: Response < super :: ListTableSpecsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ListTableSpecs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a table spec." ] pub async fn update_table_spec ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateTableSpecRequest > , ) -> Result < tonic :: Response < super :: TableSpec > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/UpdateTableSpec" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a column spec." ] pub async fn get_column_spec ( & mut self , request : impl tonic :: IntoRequest < super :: GetColumnSpecRequest > , ) -> Result < tonic :: Response < super :: ColumnSpec > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/GetColumnSpec" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists column specs in a table spec." ] pub async fn list_column_specs ( & mut self , request : impl tonic :: IntoRequest < super :: ListColumnSpecsRequest > , ) -> Result < tonic :: Response < super :: ListColumnSpecsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ListColumnSpecs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a column spec." ] pub async fn update_column_spec ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateColumnSpecRequest > , ) -> Result < tonic :: Response < super :: ColumnSpec > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/UpdateColumnSpec" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a model." ] # [ doc = " Returns a Model in the [response][google.longrunning.Operation.response]" ] # [ doc = " field when it completes." ] # [ doc = " When you create a model, several model evaluations are created for it:" ] # [ doc = " a global evaluation, and one evaluation for each annotation spec." ] pub async fn create_model ( & mut self , request : impl tonic :: IntoRequest < super :: CreateModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/CreateModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a model." ] pub async fn get_model ( & mut self , request : impl tonic :: IntoRequest < super :: GetModelRequest > , ) -> Result < tonic :: Response < super :: Model > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/GetModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists models." ] pub async fn list_models ( & mut self , request : impl tonic :: IntoRequest < super :: ListModelsRequest > , ) -> Result < tonic :: Response < super :: ListModelsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ListModels" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a model." ] # [ doc = " Returns `google.protobuf.Empty` in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes," ] # [ doc = " and `delete_details` in the" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field." ] pub async fn delete_model ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/DeleteModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deploys a model. If a model is already deployed, deploying it with the" ] # [ doc = " same parameters has no effect. Deploying with different parametrs" ] # [ doc = " (as e.g. changing" ] # [ doc = "" ] # [ doc = " [node_number][google.cloud.automl.v1beta1.ImageObjectDetectionModelDeploymentMetadata.node_number])" ] # [ doc = " will reset the deployment state without pausing the model's availability." ] # [ doc = "" ] # [ doc = " Only applicable for Text Classification, Image Object Detection , Tables, and Image Segmentation; all other domains manage" ] # [ doc = " deployment automatically." ] # [ doc = "" ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn deploy_model ( & mut self , request : impl tonic :: IntoRequest < super :: DeployModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/DeployModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Undeploys a model. If the model is not deployed this method has no effect." ] # [ doc = "" ] # [ doc = " Only applicable for Text Classification, Image Object Detection and Tables;" ] # [ doc = " all other domains manage deployment automatically." ] # [ doc = "" ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn undeploy_model ( & mut self , request : impl tonic :: IntoRequest < super :: UndeployModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/UndeployModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports a trained, \"export-able\", model to a user specified Google Cloud" ] # [ doc = " Storage location. A model is considered export-able if and only if it has" ] # [ doc = " an export format defined for it in" ] # [ doc = "" ] # [ doc = " [ModelExportOutputConfig][google.cloud.automl.v1beta1.ModelExportOutputConfig]." ] # [ doc = "" ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn export_model ( & mut self , request : impl tonic :: IntoRequest < super :: ExportModelRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ExportModel" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports examples on which the model was evaluated (i.e. which were in the" ] # [ doc = " TEST set of the dataset the model was created from), together with their" ] # [ doc = " ground truth annotations and the annotations created (predicted) by the" ] # [ doc = " model." ] # [ doc = " The examples, ground truth and predictions are exported in the state" ] # [ doc = " they were at the moment the model was evaluated." ] # [ doc = "" ] # [ doc = " This export is available only for 30 days since the model evaluation is" ] # [ doc = " created." ] # [ doc = "" ] # [ doc = " Currently only available for Tables." ] # [ doc = "" ] # [ doc = " Returns an empty response in the" ] # [ doc = " [response][google.longrunning.Operation.response] field when it completes." ] pub async fn export_evaluated_examples ( & mut self , request : impl tonic :: IntoRequest < super :: ExportEvaluatedExamplesRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ExportEvaluatedExamples" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a model evaluation." ] pub async fn get_model_evaluation ( & mut self , request : impl tonic :: IntoRequest < super :: GetModelEvaluationRequest > , ) -> Result < tonic :: Response < super :: ModelEvaluation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/GetModelEvaluation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists model evaluations." ] pub async fn list_model_evaluations ( & mut self , request : impl tonic :: IntoRequest < super :: ListModelEvaluationsRequest > , ) -> Result < tonic :: Response < super :: ListModelEvaluationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.automl.v1beta1.AutoMl/ListModelEvaluations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AutoMlClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AutoMlClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AutoMlClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/speech/v1.rs:699:3939 [INFO] [stdout] | [INFO] [stdout] 699 | # [ doc = r" Generated client implementations." ] pub mod speech_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Speech API." ] pub struct SpeechClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SpeechClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs synchronous speech recognition: receive results after all audio" ] # [ doc = " has been sent and processed." ] pub async fn recognize ( & mut self , request : impl tonic :: IntoRequest < super :: RecognizeRequest > , ) -> Result < tonic :: Response < super :: RecognizeResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.speech.v1.Speech/Recognize" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Performs asynchronous speech recognition: receive results via the" ] # [ doc = " google.longrunning.Operations interface. Returns either an" ] # [ doc = " `Operation.error` or an `Operation.response` which contains" ] # [ doc = " a `LongRunningRecognizeResponse` message." ] # [ doc = " For more information on asynchronous speech recognition, see the" ] # [ doc = " [how-to](https://cloud.google.com/speech-to-text/docs/async-recognize)." ] pub async fn long_running_recognize ( & mut self , request : impl tonic :: IntoRequest < super :: LongRunningRecognizeRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.speech.v1.Speech/LongRunningRecognize" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Performs bidirectional streaming speech recognition: receive results while" ] # [ doc = " sending audio. This method is only available via the gRPC API (not REST)." ] pub async fn streaming_recognize ( & mut self , request : impl tonic :: IntoStreamingRequest < Message = super :: StreamingRecognizeRequest > ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: StreamingRecognizeResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.speech.v1.Speech/StreamingRecognize" ) ; self . inner . streaming ( request . into_streaming_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SpeechClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SpeechClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SpeechClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/speech/v1p1beta1.rs:874:3960 [INFO] [stdout] | [INFO] [stdout] 874 | # [ doc = r" Generated client implementations." ] pub mod speech_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Speech API." ] pub struct SpeechClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SpeechClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs synchronous speech recognition: receive results after all audio" ] # [ doc = " has been sent and processed." ] pub async fn recognize ( & mut self , request : impl tonic :: IntoRequest < super :: RecognizeRequest > , ) -> Result < tonic :: Response < super :: RecognizeResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.speech.v1p1beta1.Speech/Recognize" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Performs asynchronous speech recognition: receive results via the" ] # [ doc = " google.longrunning.Operations interface. Returns either an" ] # [ doc = " `Operation.error` or an `Operation.response` which contains" ] # [ doc = " a `LongRunningRecognizeResponse` message." ] # [ doc = " For more information on asynchronous speech recognition, see the" ] # [ doc = " [how-to](https://cloud.google.com/speech-to-text/docs/async-recognize)." ] pub async fn long_running_recognize ( & mut self , request : impl tonic :: IntoRequest < super :: LongRunningRecognizeRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.speech.v1p1beta1.Speech/LongRunningRecognize" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Performs bidirectional streaming speech recognition: receive results while" ] # [ doc = " sending audio. This method is only available via the gRPC API (not REST)." ] pub async fn streaming_recognize ( & mut self , request : impl tonic :: IntoStreamingRequest < Message = super :: StreamingRecognizeRequest > ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: StreamingRecognizeResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.speech.v1p1beta1.Speech/StreamingRecognize" ) ; self . inner . streaming ( request . into_streaming_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SpeechClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SpeechClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SpeechClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/iot/v1.rs:796:16069 [INFO] [stdout] | [INFO] [stdout] 796 | # [ doc = r" Generated client implementations." ] pub mod device_manager_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Internet of Things (IoT) service. Securely connect and manage IoT devices." ] pub struct DeviceManagerClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DeviceManagerClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a device registry that contains devices." ] pub async fn create_device_registry ( & mut self , request : impl tonic :: IntoRequest < super :: CreateDeviceRegistryRequest > , ) -> Result < tonic :: Response < super :: DeviceRegistry > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/CreateDeviceRegistry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a device registry configuration." ] pub async fn get_device_registry ( & mut self , request : impl tonic :: IntoRequest < super :: GetDeviceRegistryRequest > , ) -> Result < tonic :: Response < super :: DeviceRegistry > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/GetDeviceRegistry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a device registry configuration." ] pub async fn update_device_registry ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateDeviceRegistryRequest > , ) -> Result < tonic :: Response < super :: DeviceRegistry > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/UpdateDeviceRegistry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a device registry configuration." ] pub async fn delete_device_registry ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteDeviceRegistryRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/DeleteDeviceRegistry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists device registries." ] pub async fn list_device_registries ( & mut self , request : impl tonic :: IntoRequest < super :: ListDeviceRegistriesRequest > , ) -> Result < tonic :: Response < super :: ListDeviceRegistriesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/ListDeviceRegistries" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a device in a device registry." ] pub async fn create_device ( & mut self , request : impl tonic :: IntoRequest < super :: CreateDeviceRequest > , ) -> Result < tonic :: Response < super :: Device > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/CreateDevice" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets details about a device." ] pub async fn get_device ( & mut self , request : impl tonic :: IntoRequest < super :: GetDeviceRequest > , ) -> Result < tonic :: Response < super :: Device > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/GetDevice" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a device." ] pub async fn update_device ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateDeviceRequest > , ) -> Result < tonic :: Response < super :: Device > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/UpdateDevice" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a device." ] pub async fn delete_device ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteDeviceRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/DeleteDevice" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " List devices in a device registry." ] pub async fn list_devices ( & mut self , request : impl tonic :: IntoRequest < super :: ListDevicesRequest > , ) -> Result < tonic :: Response < super :: ListDevicesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/ListDevices" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Modifies the configuration for the device, which is eventually sent from" ] # [ doc = " the Cloud IoT Core servers. Returns the modified configuration version and" ] # [ doc = " its metadata." ] pub async fn modify_cloud_to_device_config ( & mut self , request : impl tonic :: IntoRequest < super :: ModifyCloudToDeviceConfigRequest > , ) -> Result < tonic :: Response < super :: DeviceConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/ModifyCloudToDeviceConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the last few versions of the device configuration in descending" ] # [ doc = " order (i.e.: newest first)." ] pub async fn list_device_config_versions ( & mut self , request : impl tonic :: IntoRequest < super :: ListDeviceConfigVersionsRequest > , ) -> Result < tonic :: Response < super :: ListDeviceConfigVersionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/ListDeviceConfigVersions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the last few versions of the device state in descending order (i.e.:" ] # [ doc = " newest first)." ] pub async fn list_device_states ( & mut self , request : impl tonic :: IntoRequest < super :: ListDeviceStatesRequest > , ) -> Result < tonic :: Response < super :: ListDeviceStatesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/ListDeviceStates" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on the specified resource. Replaces any" ] # [ doc = " existing policy." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a resource." ] # [ doc = " Returns an empty policy if the resource exists and does not have a policy" ] # [ doc = " set." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that a caller has on the specified resource." ] # [ doc = " If the resource does not exist, this will return an empty set of" ] # [ doc = " permissions, not a NOT_FOUND error." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sends a command to the specified device. In order for a device to be able" ] # [ doc = " to receive commands, it must:" ] # [ doc = " 1) be connected to Cloud IoT Core using the MQTT protocol, and" ] # [ doc = " 2) be subscribed to the group of MQTT topics specified by" ] # [ doc = " /devices/{device-id}/commands/#. This subscription will receive commands" ] # [ doc = " at the top-level topic /devices/{device-id}/commands as well as commands" ] # [ doc = " for subfolders, like /devices/{device-id}/commands/subfolder." ] # [ doc = " Note that subscribing to specific subfolders is not supported." ] # [ doc = " If the command could not be delivered to the device, this method will" ] # [ doc = " return an error; in particular, if the device is not subscribed, this" ] # [ doc = " method will return FAILED_PRECONDITION. Otherwise, this method will" ] # [ doc = " return OK. If the subscription is QoS 1, at least once delivery will be" ] # [ doc = " guaranteed; for QoS 0, no acknowledgment will be expected from the device." ] pub async fn send_command_to_device ( & mut self , request : impl tonic :: IntoRequest < super :: SendCommandToDeviceRequest > , ) -> Result < tonic :: Response < super :: SendCommandToDeviceResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/SendCommandToDevice" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Associates the device with the gateway." ] pub async fn bind_device_to_gateway ( & mut self , request : impl tonic :: IntoRequest < super :: BindDeviceToGatewayRequest > , ) -> Result < tonic :: Response < super :: BindDeviceToGatewayResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/BindDeviceToGateway" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the association between the device and the gateway." ] pub async fn unbind_device_from_gateway ( & mut self , request : impl tonic :: IntoRequest < super :: UnbindDeviceFromGatewayRequest > , ) -> Result < tonic :: Response < super :: UnbindDeviceFromGatewayResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.iot.v1.DeviceManager/UnbindDeviceFromGateway" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DeviceManagerClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DeviceManagerClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DeviceManagerClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/videointelligence/v1.rs:806:2328 [INFO] [stdout] | [INFO] [stdout] 806 | # [ doc = r" Generated client implementations." ] pub mod video_intelligence_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Video Intelligence API." ] pub struct VideoIntelligenceServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > VideoIntelligenceServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs asynchronous video annotation. Progress and results can be" ] # [ doc = " retrieved through the `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `AnnotateVideoProgress` (progress)." ] # [ doc = " `Operation.response` contains `AnnotateVideoResponse` (results)." ] pub async fn annotate_video ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateVideoRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.videointelligence.v1.VideoIntelligenceService/AnnotateVideo" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for VideoIntelligenceServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for VideoIntelligenceServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "VideoIntelligenceServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/videointelligence/v1beta2.rs:363:2333 [INFO] [stdout] | [INFO] [stdout] 363 | # [ doc = r" Generated client implementations." ] pub mod video_intelligence_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Video Intelligence API." ] pub struct VideoIntelligenceServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > VideoIntelligenceServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs asynchronous video annotation. Progress and results can be" ] # [ doc = " retrieved through the `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `AnnotateVideoProgress` (progress)." ] # [ doc = " `Operation.response` contains `AnnotateVideoResponse` (results)." ] pub async fn annotate_video ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateVideoRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.videointelligence.v1beta2.VideoIntelligenceService/AnnotateVideo" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for VideoIntelligenceServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for VideoIntelligenceServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "VideoIntelligenceServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/videointelligence/v1p1beta1.rs:401:2335 [INFO] [stdout] | [INFO] [stdout] 401 | # [ doc = r" Generated client implementations." ] pub mod video_intelligence_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Video Intelligence API." ] pub struct VideoIntelligenceServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > VideoIntelligenceServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs asynchronous video annotation. Progress and results can be" ] # [ doc = " retrieved through the `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `AnnotateVideoProgress` (progress)." ] # [ doc = " `Operation.response` contains `AnnotateVideoResponse` (results)." ] pub async fn annotate_video ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateVideoRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.videointelligence.v1p1beta1.VideoIntelligenceService/AnnotateVideo" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for VideoIntelligenceServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for VideoIntelligenceServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "VideoIntelligenceServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/videointelligence/v1p2beta1.rs:436:2335 [INFO] [stdout] | [INFO] [stdout] 436 | # [ doc = r" Generated client implementations." ] pub mod video_intelligence_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Video Intelligence API." ] pub struct VideoIntelligenceServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > VideoIntelligenceServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs asynchronous video annotation. Progress and results can be" ] # [ doc = " retrieved through the `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `AnnotateVideoProgress` (progress)." ] # [ doc = " `Operation.response` contains `AnnotateVideoResponse` (results)." ] pub async fn annotate_video ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateVideoRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.videointelligence.v1p2beta1.VideoIntelligenceService/AnnotateVideo" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for VideoIntelligenceServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for VideoIntelligenceServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "VideoIntelligenceServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/videointelligence/v1p3beta1.rs:1054:4684 [INFO] [stdout] | [INFO] [stdout] 1054 | # [ doc = r" Generated client implementations." ] pub mod video_intelligence_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Video Intelligence API." ] pub struct VideoIntelligenceServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > VideoIntelligenceServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs asynchronous video annotation. Progress and results can be" ] # [ doc = " retrieved through the `google.longrunning.Operations` interface." ] # [ doc = " `Operation.metadata` contains `AnnotateVideoProgress` (progress)." ] # [ doc = " `Operation.response` contains `AnnotateVideoResponse` (results)." ] pub async fn annotate_video ( & mut self , request : impl tonic :: IntoRequest < super :: AnnotateVideoRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.videointelligence.v1p3beta1.VideoIntelligenceService/AnnotateVideo" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for VideoIntelligenceServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for VideoIntelligenceServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "VideoIntelligenceServiceClient {{ ... }}" ) } } } # [ doc = r" Generated client implementations." ] pub mod streaming_video_intelligence_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements streaming Google Cloud Video Intelligence API." ] pub struct StreamingVideoIntelligenceServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > StreamingVideoIntelligenceServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs video annotation with bidirectional streaming: emitting results" ] # [ doc = " while sending video/audio bytes." ] # [ doc = " This method is only available via the gRPC API (not REST)." ] pub async fn streaming_annotate_video ( & mut self , request : impl tonic :: IntoStreamingRequest < Message = super :: StreamingAnnotateVideoRequest > ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: StreamingAnnotateVideoResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.videointelligence.v1p3beta1.StreamingVideoIntelligenceService/StreamingAnnotateVideo" ) ; self . inner . streaming ( request . into_streaming_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for StreamingVideoIntelligenceServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for StreamingVideoIntelligenceServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "StreamingVideoIntelligenceServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/memcache/v1beta2.rs:354:7475 [INFO] [stdout] | [INFO] [stdout] 354 | # [ doc = r" Generated client implementations." ] pub mod cloud_memcache_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Configures and manages Cloud Memorystore for Memcached instances." ] # [ doc = "" ] # [ doc = "" ] # [ doc = " The `memcache.googleapis.com` service implements the Google Cloud Memorystore" ] # [ doc = " for Memcached API and defines the following resource model for managing" ] # [ doc = " Memorystore Memcached (also called Memcached below) instances:" ] # [ doc = " * The service works with a collection of cloud projects, named: `/projects/*`" ] # [ doc = " * Each project has a collection of available locations, named: `/locations/*`" ] # [ doc = " * Each location has a collection of Memcached instances, named:" ] # [ doc = " `/instances/*`" ] # [ doc = " * As such, Memcached instances are resources of the form:" ] # [ doc = " `/projects/{project_id}/locations/{location_id}/instances/{instance_id}`" ] # [ doc = "" ] # [ doc = " Note that location_id must be refering to a GCP `region`; for example:" ] # [ doc = " * `projects/my-memcached-project/locations/us-central1/instances/my-memcached`" ] pub struct CloudMemcacheClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudMemcacheClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists Instances in a given project and location." ] pub async fn list_instances ( & mut self , request : impl tonic :: IntoRequest < super :: ListInstancesRequest > , ) -> Result < tonic :: Response < super :: ListInstancesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.memcache.v1beta2.CloudMemcache/ListInstances" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets details of a single Instance." ] pub async fn get_instance ( & mut self , request : impl tonic :: IntoRequest < super :: GetInstanceRequest > , ) -> Result < tonic :: Response < super :: Instance > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.memcache.v1beta2.CloudMemcache/GetInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new Instance in a given project and location." ] pub async fn create_instance ( & mut self , request : impl tonic :: IntoRequest < super :: CreateInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.memcache.v1beta2.CloudMemcache/CreateInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing Instance in a given project and location." ] pub async fn update_instance ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.memcache.v1beta2.CloudMemcache/UpdateInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the defined Memcached Parameters for an existing Instance." ] # [ doc = " This method only stages the parameters, it must be followed by" ] # [ doc = " ApplyParameters to apply the parameters to nodes of the Memcached Instance." ] pub async fn update_parameters ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateParametersRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.memcache.v1beta2.CloudMemcache/UpdateParameters" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a single Instance." ] pub async fn delete_instance ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.memcache.v1beta2.CloudMemcache/DeleteInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " ApplyParameters will update current set of Parameters to the set of" ] # [ doc = " specified nodes of the Memcached Instance." ] pub async fn apply_parameters ( & mut self , request : impl tonic :: IntoRequest < super :: ApplyParametersRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.memcache.v1beta2.CloudMemcache/ApplyParameters" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudMemcacheClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudMemcacheClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudMemcacheClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/servicedirectory/v1beta1.rs:410:14691 [INFO] [stdout] | [INFO] [stdout] 410 | # [ doc = r" Generated client implementations." ] pub mod registration_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service Directory API for registering services. It defines the following" ] # [ doc = " resource model:" ] # [ doc = "" ] # [ doc = " - The API has a collection of" ] # [ doc = " [Namespace][google.cloud.servicedirectory.v1beta1.Namespace]" ] # [ doc = " resources, named `projects/*/locations/*/namespaces/*`." ] # [ doc = "" ] # [ doc = " - Each Namespace has a collection of" ] # [ doc = " [Service][google.cloud.servicedirectory.v1beta1.Service] resources, named" ] # [ doc = " `projects/*/locations/*/namespaces/*/services/*`." ] # [ doc = "" ] # [ doc = " - Each Service has a collection of" ] # [ doc = " [Endpoint][google.cloud.servicedirectory.v1beta1.Endpoint]" ] # [ doc = " resources, named" ] # [ doc = " `projects/*/locations/*/namespaces/*/services/*/endpoints/*`." ] pub struct RegistrationServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > RegistrationServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a namespace, and returns the new Namespace." ] pub async fn create_namespace ( & mut self , request : impl tonic :: IntoRequest < super :: CreateNamespaceRequest > , ) -> Result < tonic :: Response < super :: Namespace > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/CreateNamespace" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all namespaces." ] pub async fn list_namespaces ( & mut self , request : impl tonic :: IntoRequest < super :: ListNamespacesRequest > , ) -> Result < tonic :: Response < super :: ListNamespacesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/ListNamespaces" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a namespace." ] pub async fn get_namespace ( & mut self , request : impl tonic :: IntoRequest < super :: GetNamespaceRequest > , ) -> Result < tonic :: Response < super :: Namespace > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/GetNamespace" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a namespace." ] pub async fn update_namespace ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateNamespaceRequest > , ) -> Result < tonic :: Response < super :: Namespace > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/UpdateNamespace" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a namespace. This also deletes all services and endpoints in" ] # [ doc = " the namespace." ] pub async fn delete_namespace ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteNamespaceRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/DeleteNamespace" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a service, and returns the new Service." ] pub async fn create_service ( & mut self , request : impl tonic :: IntoRequest < super :: CreateServiceRequest > , ) -> Result < tonic :: Response < super :: Service > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/CreateService" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all services belonging to a namespace." ] pub async fn list_services ( & mut self , request : impl tonic :: IntoRequest < super :: ListServicesRequest > , ) -> Result < tonic :: Response < super :: ListServicesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/ListServices" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a service." ] pub async fn get_service ( & mut self , request : impl tonic :: IntoRequest < super :: GetServiceRequest > , ) -> Result < tonic :: Response < super :: Service > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/GetService" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a service." ] pub async fn update_service ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateServiceRequest > , ) -> Result < tonic :: Response < super :: Service > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/UpdateService" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a service. This also deletes all endpoints associated with" ] # [ doc = " the service." ] pub async fn delete_service ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteServiceRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/DeleteService" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a endpoint, and returns the new Endpoint." ] pub async fn create_endpoint ( & mut self , request : impl tonic :: IntoRequest < super :: CreateEndpointRequest > , ) -> Result < tonic :: Response < super :: Endpoint > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/CreateEndpoint" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all endpoints." ] pub async fn list_endpoints ( & mut self , request : impl tonic :: IntoRequest < super :: ListEndpointsRequest > , ) -> Result < tonic :: Response < super :: ListEndpointsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/ListEndpoints" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a endpoint." ] pub async fn get_endpoint ( & mut self , request : impl tonic :: IntoRequest < super :: GetEndpointRequest > , ) -> Result < tonic :: Response < super :: Endpoint > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/GetEndpoint" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a endpoint." ] pub async fn update_endpoint ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateEndpointRequest > , ) -> Result < tonic :: Response < super :: Endpoint > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/UpdateEndpoint" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a endpoint." ] pub async fn delete_endpoint ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteEndpointRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/DeleteEndpoint" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the IAM Policy for a resource (namespace or service only)." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the IAM Policy for a resource (namespace or service only)." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Tests IAM permissions for a resource (namespace or service only)." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.servicedirectory.v1beta1.RegistrationService/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for RegistrationServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for RegistrationServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "RegistrationServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/recommender/v1.rs:356:6787 [INFO] [stdout] | [INFO] [stdout] 356 | # [ doc = r" Generated client implementations." ] pub mod recommender_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Provides recommendations for cloud customers for various categories like" ] # [ doc = " performance optimization, cost savings, reliability, feature discovery, etc." ] # [ doc = " These recommendations are generated automatically based on analysis of user" ] # [ doc = " resources, configuration and monitoring metrics." ] pub struct RecommenderClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > RecommenderClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists recommendations for a Cloud project. Requires the recommender.*.list" ] # [ doc = " IAM permission for the specified recommender." ] pub async fn list_recommendations ( & mut self , request : impl tonic :: IntoRequest < super :: ListRecommendationsRequest > , ) -> Result < tonic :: Response < super :: ListRecommendationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1.Recommender/ListRecommendations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the requested recommendation. Requires the recommender.*.get" ] # [ doc = " IAM permission for the specified recommender." ] pub async fn get_recommendation ( & mut self , request : impl tonic :: IntoRequest < super :: GetRecommendationRequest > , ) -> Result < tonic :: Response < super :: Recommendation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1.Recommender/GetRecommendation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mark the Recommendation State as Claimed. Users can use this method to" ] # [ doc = " indicate to the Recommender API that they are starting to apply the" ] # [ doc = " recommendation themselves. This stops the recommendation content from being" ] # [ doc = " updated." ] # [ doc = "" ] # [ doc = " MarkRecommendationClaimed can be applied to recommendations in CLAIMED," ] # [ doc = " SUCCEEDED, FAILED, or ACTIVE state." ] # [ doc = "" ] # [ doc = " Requires the recommender.*.update IAM permission for the specified" ] # [ doc = " recommender." ] pub async fn mark_recommendation_claimed ( & mut self , request : impl tonic :: IntoRequest < super :: MarkRecommendationClaimedRequest > , ) -> Result < tonic :: Response < super :: Recommendation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1.Recommender/MarkRecommendationClaimed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mark the Recommendation State as Succeeded. Users can use this method to" ] # [ doc = " indicate to the Recommender API that they have applied the recommendation" ] # [ doc = " themselves, and the operation was successful. This stops the recommendation" ] # [ doc = " content from being updated." ] # [ doc = "" ] # [ doc = " MarkRecommendationSucceeded can be applied to recommendations in ACTIVE," ] # [ doc = " CLAIMED, SUCCEEDED, or FAILED state." ] # [ doc = "" ] # [ doc = " Requires the recommender.*.update IAM permission for the specified" ] # [ doc = " recommender." ] pub async fn mark_recommendation_succeeded ( & mut self , request : impl tonic :: IntoRequest < super :: MarkRecommendationSucceededRequest > , ) -> Result < tonic :: Response < super :: Recommendation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1.Recommender/MarkRecommendationSucceeded" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Mark the Recommendation State as Failed. Users can use this method to" ] # [ doc = " indicate to the Recommender API that they have applied the recommendation" ] # [ doc = " themselves, and the operation failed. This stops the recommendation content" ] # [ doc = " from being updated." ] # [ doc = "" ] # [ doc = " MarkRecommendationFailed can be applied to recommendations in ACTIVE," ] # [ doc = " CLAIMED, SUCCEEDED, or FAILED state." ] # [ doc = "" ] # [ doc = " Requires the recommender.*.update IAM permission for the specified" ] # [ doc = " recommender." ] pub async fn mark_recommendation_failed ( & mut self , request : impl tonic :: IntoRequest < super :: MarkRecommendationFailedRequest > , ) -> Result < tonic :: Response < super :: Recommendation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1.Recommender/MarkRecommendationFailed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for RecommenderClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for RecommenderClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "RecommenderClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/recommender/v1beta1.rs:530:9631 [INFO] [stdout] | [INFO] [stdout] 530 | # [ doc = r" Generated client implementations." ] pub mod recommender_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Provides insights and recommendations for cloud customers for various" ] # [ doc = " categories like performance optimization, cost savings, reliability, feature" ] # [ doc = " discovery, etc. Insights and recommendations are generated automatically" ] # [ doc = " based on analysis of user resources, configuration and monitoring metrics." ] pub struct RecommenderClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > RecommenderClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists insights for a Cloud project. Requires the recommender.*.list IAM" ] # [ doc = " permission for the specified insight type." ] pub async fn list_insights ( & mut self , request : impl tonic :: IntoRequest < super :: ListInsightsRequest > , ) -> Result < tonic :: Response < super :: ListInsightsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1beta1.Recommender/ListInsights" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the requested insight. Requires the recommender.*.get IAM permission" ] # [ doc = " for the specified insight type." ] pub async fn get_insight ( & mut self , request : impl tonic :: IntoRequest < super :: GetInsightRequest > , ) -> Result < tonic :: Response < super :: Insight > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1beta1.Recommender/GetInsight" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Marks the Insight State as Accepted. Users can use this method to" ] # [ doc = " indicate to the Recommender API that they have applied some action based" ] # [ doc = " on the insight. This stops the insight content from being updated." ] # [ doc = "" ] # [ doc = " MarkInsightAccepted can be applied to insights in ACTIVE state. Requires" ] # [ doc = " the recommender.*.update IAM permission for the specified insight." ] pub async fn mark_insight_accepted ( & mut self , request : impl tonic :: IntoRequest < super :: MarkInsightAcceptedRequest > , ) -> Result < tonic :: Response < super :: Insight > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1beta1.Recommender/MarkInsightAccepted" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists recommendations for a Cloud project. Requires the recommender.*.list" ] # [ doc = " IAM permission for the specified recommender." ] pub async fn list_recommendations ( & mut self , request : impl tonic :: IntoRequest < super :: ListRecommendationsRequest > , ) -> Result < tonic :: Response < super :: ListRecommendationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1beta1.Recommender/ListRecommendations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the requested recommendation. Requires the recommender.*.get" ] # [ doc = " IAM permission for the specified recommender." ] pub async fn get_recommendation ( & mut self , request : impl tonic :: IntoRequest < super :: GetRecommendationRequest > , ) -> Result < tonic :: Response < super :: Recommendation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1beta1.Recommender/GetRecommendation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Marks the Recommendation State as Claimed. Users can use this method to" ] # [ doc = " indicate to the Recommender API that they are starting to apply the" ] # [ doc = " recommendation themselves. This stops the recommendation content from being" ] # [ doc = " updated. Associated insights are frozen and placed in the ACCEPTED state." ] # [ doc = "" ] # [ doc = " MarkRecommendationClaimed can be applied to recommendations in CLAIMED or" ] # [ doc = " ACTIVE state." ] # [ doc = "" ] # [ doc = " Requires the recommender.*.update IAM permission for the specified" ] # [ doc = " recommender." ] pub async fn mark_recommendation_claimed ( & mut self , request : impl tonic :: IntoRequest < super :: MarkRecommendationClaimedRequest > , ) -> Result < tonic :: Response < super :: Recommendation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1beta1.Recommender/MarkRecommendationClaimed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Marks the Recommendation State as Succeeded. Users can use this method to" ] # [ doc = " indicate to the Recommender API that they have applied the recommendation" ] # [ doc = " themselves, and the operation was successful. This stops the recommendation" ] # [ doc = " content from being updated. Associated insights are frozen and placed in" ] # [ doc = " the ACCEPTED state." ] # [ doc = "" ] # [ doc = " MarkRecommendationSucceeded can be applied to recommendations in ACTIVE," ] # [ doc = " CLAIMED, SUCCEEDED, or FAILED state." ] # [ doc = "" ] # [ doc = " Requires the recommender.*.update IAM permission for the specified" ] # [ doc = " recommender." ] pub async fn mark_recommendation_succeeded ( & mut self , request : impl tonic :: IntoRequest < super :: MarkRecommendationSucceededRequest > , ) -> Result < tonic :: Response < super :: Recommendation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1beta1.Recommender/MarkRecommendationSucceeded" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Marks the Recommendation State as Failed. Users can use this method to" ] # [ doc = " indicate to the Recommender API that they have applied the recommendation" ] # [ doc = " themselves, and the operation failed. This stops the recommendation content" ] # [ doc = " from being updated. Associated insights are frozen and placed in the" ] # [ doc = " ACCEPTED state." ] # [ doc = "" ] # [ doc = " MarkRecommendationFailed can be applied to recommendations in ACTIVE," ] # [ doc = " CLAIMED, SUCCEEDED, or FAILED state." ] # [ doc = "" ] # [ doc = " Requires the recommender.*.update IAM permission for the specified" ] # [ doc = " recommender." ] pub async fn mark_recommendation_failed ( & mut self , request : impl tonic :: IntoRequest < super :: MarkRecommendationFailedRequest > , ) -> Result < tonic :: Response < super :: Recommendation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.recommender.v1beta1.Recommender/MarkRecommendationFailed" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for RecommenderClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for RecommenderClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "RecommenderClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/ml/v1.rs:1067:2268 [INFO] [stdout] | [INFO] [stdout] 1067 | # [ doc = r" Generated client implementations." ] pub mod project_management_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Allows retrieving project related information." ] pub struct ProjectManagementServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ProjectManagementServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Get the service account information associated with your project. You need" ] # [ doc = " this information in order to grant the service account persmissions for" ] # [ doc = " the Google Cloud Storage location where you put your model training code" ] # [ doc = " for training the model with Google Cloud Machine Learning." ] pub async fn get_config ( & mut self , request : impl tonic :: IntoRequest < super :: GetConfigRequest > , ) -> Result < tonic :: Response < super :: GetConfigResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.ml.v1.ProjectManagementService/GetConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ProjectManagementServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ProjectManagementServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ProjectManagementServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/datalabeling/v1beta1.rs:2459:27070 [INFO] [stdout] | [INFO] [stdout] 2459 | # [ doc = r" Generated client implementations." ] pub mod data_labeling_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; pub struct DataLabelingServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DataLabelingServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates dataset. If success return a Dataset resource." ] pub async fn create_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: CreateDatasetRequest > , ) -> Result < tonic :: Response < super :: Dataset > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/CreateDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets dataset by resource name." ] pub async fn get_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: GetDatasetRequest > , ) -> Result < tonic :: Response < super :: Dataset > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/GetDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists datasets under a project. Pagination is supported." ] pub async fn list_datasets ( & mut self , request : impl tonic :: IntoRequest < super :: ListDatasetsRequest > , ) -> Result < tonic :: Response < super :: ListDatasetsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ListDatasets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a dataset by resource name." ] pub async fn delete_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteDatasetRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/DeleteDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Imports data into dataset based on source locations defined in request." ] # [ doc = " It can be called multiple times for the same dataset. Each dataset can" ] # [ doc = " only have one long running operation running on it. For example, no" ] # [ doc = " labeling task (also long running operation) can be started while" ] # [ doc = " importing is still ongoing. Vice versa." ] pub async fn import_data ( & mut self , request : impl tonic :: IntoRequest < super :: ImportDataRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ImportData" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports data and annotations from dataset." ] pub async fn export_data ( & mut self , request : impl tonic :: IntoRequest < super :: ExportDataRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ExportData" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a data item in a dataset by resource name. This API can be" ] # [ doc = " called after data are imported into dataset." ] pub async fn get_data_item ( & mut self , request : impl tonic :: IntoRequest < super :: GetDataItemRequest > , ) -> Result < tonic :: Response < super :: DataItem > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/GetDataItem" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists data items in a dataset. This API can be called after data" ] # [ doc = " are imported into dataset. Pagination is supported." ] pub async fn list_data_items ( & mut self , request : impl tonic :: IntoRequest < super :: ListDataItemsRequest > , ) -> Result < tonic :: Response < super :: ListDataItemsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ListDataItems" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an annotated dataset by resource name." ] pub async fn get_annotated_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: GetAnnotatedDatasetRequest > , ) -> Result < tonic :: Response < super :: AnnotatedDataset > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/GetAnnotatedDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists annotated datasets for a dataset. Pagination is supported." ] pub async fn list_annotated_datasets ( & mut self , request : impl tonic :: IntoRequest < super :: ListAnnotatedDatasetsRequest > , ) -> Result < tonic :: Response < super :: ListAnnotatedDatasetsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ListAnnotatedDatasets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an annotated dataset by resource name." ] pub async fn delete_annotated_dataset ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAnnotatedDatasetRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/DeleteAnnotatedDataset" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Starts a labeling task for image. The type of image labeling task is" ] # [ doc = " configured by feature in the request." ] pub async fn label_image ( & mut self , request : impl tonic :: IntoRequest < super :: LabelImageRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/LabelImage" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Starts a labeling task for video. The type of video labeling task is" ] # [ doc = " configured by feature in the request." ] pub async fn label_video ( & mut self , request : impl tonic :: IntoRequest < super :: LabelVideoRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/LabelVideo" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Starts a labeling task for text. The type of text labeling task is" ] # [ doc = " configured by feature in the request." ] pub async fn label_text ( & mut self , request : impl tonic :: IntoRequest < super :: LabelTextRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/LabelText" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an example by resource name, including both data and annotation." ] pub async fn get_example ( & mut self , request : impl tonic :: IntoRequest < super :: GetExampleRequest > , ) -> Result < tonic :: Response < super :: Example > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/GetExample" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists examples in an annotated dataset. Pagination is supported." ] pub async fn list_examples ( & mut self , request : impl tonic :: IntoRequest < super :: ListExamplesRequest > , ) -> Result < tonic :: Response < super :: ListExamplesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ListExamples" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates an annotation spec set by providing a set of labels." ] pub async fn create_annotation_spec_set ( & mut self , request : impl tonic :: IntoRequest < super :: CreateAnnotationSpecSetRequest > , ) -> Result < tonic :: Response < super :: AnnotationSpecSet > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/CreateAnnotationSpecSet" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an annotation spec set by resource name." ] pub async fn get_annotation_spec_set ( & mut self , request : impl tonic :: IntoRequest < super :: GetAnnotationSpecSetRequest > , ) -> Result < tonic :: Response < super :: AnnotationSpecSet > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/GetAnnotationSpecSet" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists annotation spec sets for a project. Pagination is supported." ] pub async fn list_annotation_spec_sets ( & mut self , request : impl tonic :: IntoRequest < super :: ListAnnotationSpecSetsRequest > , ) -> Result < tonic :: Response < super :: ListAnnotationSpecSetsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ListAnnotationSpecSets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an annotation spec set by resource name." ] pub async fn delete_annotation_spec_set ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAnnotationSpecSetRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/DeleteAnnotationSpecSet" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates an instruction for how data should be labeled." ] pub async fn create_instruction ( & mut self , request : impl tonic :: IntoRequest < super :: CreateInstructionRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/CreateInstruction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an instruction by resource name." ] pub async fn get_instruction ( & mut self , request : impl tonic :: IntoRequest < super :: GetInstructionRequest > , ) -> Result < tonic :: Response < super :: Instruction > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/GetInstruction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists instructions for a project. Pagination is supported." ] pub async fn list_instructions ( & mut self , request : impl tonic :: IntoRequest < super :: ListInstructionsRequest > , ) -> Result < tonic :: Response < super :: ListInstructionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ListInstructions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an instruction object by resource name." ] pub async fn delete_instruction ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteInstructionRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/DeleteInstruction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an evaluation by resource name (to search, use" ] # [ doc = " [projects.evaluations.search][google.cloud.datalabeling.v1beta1.DataLabelingService.SearchEvaluations])." ] pub async fn get_evaluation ( & mut self , request : impl tonic :: IntoRequest < super :: GetEvaluationRequest > , ) -> Result < tonic :: Response < super :: Evaluation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/GetEvaluation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Searches [evaluations][google.cloud.datalabeling.v1beta1.Evaluation] within a project." ] pub async fn search_evaluations ( & mut self , request : impl tonic :: IntoRequest < super :: SearchEvaluationsRequest > , ) -> Result < tonic :: Response < super :: SearchEvaluationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/SearchEvaluations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Searches example comparisons from an evaluation. The return format is a" ] # [ doc = " list of example comparisons that show ground truth and prediction(s) for" ] # [ doc = " a single input. Search by providing an evaluation ID." ] pub async fn search_example_comparisons ( & mut self , request : impl tonic :: IntoRequest < super :: SearchExampleComparisonsRequest > , ) -> Result < tonic :: Response < super :: SearchExampleComparisonsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/SearchExampleComparisons" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates an evaluation job." ] pub async fn create_evaluation_job ( & mut self , request : impl tonic :: IntoRequest < super :: CreateEvaluationJobRequest > , ) -> Result < tonic :: Response < super :: EvaluationJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/CreateEvaluationJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an evaluation job. You can only update certain fields of the job's" ] # [ doc = " [EvaluationJobConfig][google.cloud.datalabeling.v1beta1.EvaluationJobConfig]: `humanAnnotationConfig.instruction`," ] # [ doc = " `exampleCount`, and `exampleSamplePercentage`." ] # [ doc = "" ] # [ doc = " If you want to change any other aspect of the evaluation job, you must" ] # [ doc = " delete the job and create a new one." ] pub async fn update_evaluation_job ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateEvaluationJobRequest > , ) -> Result < tonic :: Response < super :: EvaluationJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/UpdateEvaluationJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an evaluation job by resource name." ] pub async fn get_evaluation_job ( & mut self , request : impl tonic :: IntoRequest < super :: GetEvaluationJobRequest > , ) -> Result < tonic :: Response < super :: EvaluationJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/GetEvaluationJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Pauses an evaluation job. Pausing an evaluation job that is already in a" ] # [ doc = " `PAUSED` state is a no-op." ] pub async fn pause_evaluation_job ( & mut self , request : impl tonic :: IntoRequest < super :: PauseEvaluationJobRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/PauseEvaluationJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Resumes a paused evaluation job. A deleted evaluation job can't be resumed." ] # [ doc = " Resuming a running or scheduled evaluation job is a no-op." ] pub async fn resume_evaluation_job ( & mut self , request : impl tonic :: IntoRequest < super :: ResumeEvaluationJobRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ResumeEvaluationJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Stops and deletes an evaluation job." ] pub async fn delete_evaluation_job ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteEvaluationJobRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/DeleteEvaluationJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all evaluation jobs within a project with possible filters." ] # [ doc = " Pagination is supported." ] pub async fn list_evaluation_jobs ( & mut self , request : impl tonic :: IntoRequest < super :: ListEvaluationJobsRequest > , ) -> Result < tonic :: Response < super :: ListEvaluationJobsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datalabeling.v1beta1.DataLabelingService/ListEvaluationJobs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DataLabelingServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DataLabelingServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DataLabelingServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/texttospeech/v1.rs:198:2695 [INFO] [stdout] | [INFO] [stdout] 198 | # [ doc = r" Generated client implementations." ] pub mod text_to_speech_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Text-to-Speech API." ] pub struct TextToSpeechClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > TextToSpeechClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Returns a list of Voice supported for synthesis." ] pub async fn list_voices ( & mut self , request : impl tonic :: IntoRequest < super :: ListVoicesRequest > , ) -> Result < tonic :: Response < super :: ListVoicesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.texttospeech.v1.TextToSpeech/ListVoices" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Synthesizes speech synchronously: receive results after all text input" ] # [ doc = " has been processed." ] pub async fn synthesize_speech ( & mut self , request : impl tonic :: IntoRequest < super :: SynthesizeSpeechRequest > , ) -> Result < tonic :: Response < super :: SynthesizeSpeechResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.texttospeech.v1.TextToSpeech/SynthesizeSpeech" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for TextToSpeechClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for TextToSpeechClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "TextToSpeechClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/texttospeech/v1beta1.rs:198:2705 [INFO] [stdout] | [INFO] [stdout] 198 | # [ doc = r" Generated client implementations." ] pub mod text_to_speech_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Service that implements Google Cloud Text-to-Speech API." ] pub struct TextToSpeechClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > TextToSpeechClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Returns a list of Voice supported for synthesis." ] pub async fn list_voices ( & mut self , request : impl tonic :: IntoRequest < super :: ListVoicesRequest > , ) -> Result < tonic :: Response < super :: ListVoicesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.texttospeech.v1beta1.TextToSpeech/ListVoices" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Synthesizes speech synchronously: receive results after all text input" ] # [ doc = " has been processed." ] pub async fn synthesize_speech ( & mut self , request : impl tonic :: IntoRequest < super :: SynthesizeSpeechRequest > , ) -> Result < tonic :: Response < super :: SynthesizeSpeechResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.texttospeech.v1beta1.TextToSpeech/SynthesizeSpeech" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for TextToSpeechClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for TextToSpeechClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "TextToSpeechClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/functions/v1beta2.rs:433:9258 [INFO] [stdout] | [INFO] [stdout] 433 | # [ doc = r" Generated client implementations." ] pub mod cloud_functions_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " A service that application uses to manipulate triggers and functions." ] pub struct CloudFunctionsServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudFunctionsServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Returns a list of functions that belong to the requested project." ] pub async fn list_functions ( & mut self , request : impl tonic :: IntoRequest < super :: ListFunctionsRequest > , ) -> Result < tonic :: Response < super :: ListFunctionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.functions.v1beta2.CloudFunctionsService/ListFunctions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a function with the given name from the requested project." ] pub async fn get_function ( & mut self , request : impl tonic :: IntoRequest < super :: GetFunctionRequest > , ) -> Result < tonic :: Response < super :: CloudFunction > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.functions.v1beta2.CloudFunctionsService/GetFunction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new function. If a function with the given name already exists in" ] # [ doc = " the specified project, the long running operation will return" ] # [ doc = " `ALREADY_EXISTS` error." ] pub async fn create_function ( & mut self , request : impl tonic :: IntoRequest < super :: CreateFunctionRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.functions.v1beta2.CloudFunctionsService/CreateFunction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates existing function." ] pub async fn update_function ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateFunctionRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.functions.v1beta2.CloudFunctionsService/UpdateFunction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a function with the given name from the specified project. If the" ] # [ doc = " given function is used by some trigger, the trigger will be updated to" ] # [ doc = " remove this function." ] pub async fn delete_function ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteFunctionRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.functions.v1beta2.CloudFunctionsService/DeleteFunction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Synchronously invokes a deployed Cloud Function. To be used for testing" ] # [ doc = " purposes as very limited traffic is allowed. For more information on" ] # [ doc = " the actual limits refer to [API Calls](" ] # [ doc = " https://cloud.google.com/functions/quotas#rate_limits)." ] pub async fn call_function ( & mut self , request : impl tonic :: IntoRequest < super :: CallFunctionRequest > , ) -> Result < tonic :: Response < super :: CallFunctionResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.functions.v1beta2.CloudFunctionsService/CallFunction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a signed URL for uploading a function source code." ] # [ doc = " For more information about the signed URL usage see:" ] # [ doc = " https://cloud.google.com/storage/docs/access-control/signed-urls" ] # [ doc = " Once the function source code upload is complete, the used signed" ] # [ doc = " URL should be provided in CreateFunction or UpdateFunction request" ] # [ doc = " as a reference to the function source code." ] # [ doc = "" ] # [ doc = " When uploading source code to the generated signed URL, please follow" ] # [ doc = " these restrictions:" ] # [ doc = "" ] # [ doc = " * Source file type should be a zip file." ] # [ doc = " * Source file size should not exceed 100MB limit." ] # [ doc = " * No credentials should be attached - the signed URLs provide access to the" ] # [ doc = " target bucket using internal service identity; if credentials were" ] # [ doc = " attached, the identity from the credentials would be used, but that" ] # [ doc = " identity does not have permissions to upload files to the URL." ] # [ doc = "" ] # [ doc = " When making a HTTP PUT request, these two headers need to be specified:" ] # [ doc = "" ] # [ doc = " * `content-type: application/zip`" ] # [ doc = " * `x-goog-content-length-range: 0,104857600`" ] # [ doc = "" ] # [ doc = " And this header SHOULD NOT be specified:" ] # [ doc = "" ] # [ doc = " * `Authorization: Bearer YOUR_TOKEN`" ] pub async fn generate_upload_url ( & mut self , request : impl tonic :: IntoRequest < super :: GenerateUploadUrlRequest > , ) -> Result < tonic :: Response < super :: GenerateUploadUrlResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.functions.v1beta2.CloudFunctionsService/GenerateUploadUrl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a signed URL for downloading deployed function source code." ] # [ doc = " The URL is only valid for a limited period and should be used within" ] # [ doc = " minutes after generation." ] # [ doc = " For more information about the signed URL usage see:" ] # [ doc = " https://cloud.google.com/storage/docs/access-control/signed-urls" ] pub async fn generate_download_url ( & mut self , request : impl tonic :: IntoRequest < super :: GenerateDownloadUrlRequest > , ) -> Result < tonic :: Response < super :: GenerateDownloadUrlResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.functions.v1beta2.CloudFunctionsService/GenerateDownloadUrl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudFunctionsServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudFunctionsServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudFunctionsServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/policytroubleshooter/v1.rs:244:2165 [INFO] [stdout] | [INFO] [stdout] 244 | # [ doc = r" Generated client implementations." ] pub mod iam_checker_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " IAM Policy Troubleshooter service." ] # [ doc = "" ] # [ doc = " This service helps you troubleshoot access issues for Google Cloud resources." ] pub struct IamCheckerClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > IamCheckerClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Checks whether a member has a specific permission for a specific resource," ] # [ doc = " and explains why the member does or does not have that permission." ] pub async fn troubleshoot_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: TroubleshootIamPolicyRequest > , ) -> Result < tonic :: Response < super :: TroubleshootIamPolicyResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.policytroubleshooter.v1.IamChecker/TroubleshootIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for IamCheckerClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for IamCheckerClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "IamCheckerClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/location.rs:61:2753 [INFO] [stdout] | [INFO] [stdout] 61 | # [ doc = r" Generated client implementations." ] pub mod locations_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " An abstract interface that provides location-related information for" ] # [ doc = " a service. Service-specific metadata is provided through the" ] # [ doc = " [Location.metadata][google.cloud.location.Location.metadata] field." ] pub struct LocationsClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > LocationsClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists information about the supported locations for this service." ] pub async fn list_locations ( & mut self , request : impl tonic :: IntoRequest < super :: ListLocationsRequest > , ) -> Result < tonic :: Response < super :: ListLocationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.location.Locations/ListLocations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a location." ] pub async fn get_location ( & mut self , request : impl tonic :: IntoRequest < super :: GetLocationRequest > , ) -> Result < tonic :: Response < super :: Location > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.location.Locations/GetLocation" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for LocationsClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for LocationsClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "LocationsClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/datacatalog/v1.rs:1190:28425 [INFO] [stdout] | [INFO] [stdout] 1190 | # [ doc = r" Generated client implementations." ] pub mod data_catalog_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Data Catalog API service allows clients to discover, understand, and manage" ] # [ doc = " their data." ] pub struct DataCatalogClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DataCatalogClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Searches Data Catalog for multiple resources like entries, tags that" ] # [ doc = " match a query." ] # [ doc = "" ] # [ doc = " This is a custom method" ] # [ doc = " (https://cloud.google.com/apis/design/custom_methods) and does not return" ] # [ doc = " the complete resource, only the resource identifier and high level" ] # [ doc = " fields. Clients can subsequentally call `Get` methods." ] # [ doc = "" ] # [ doc = " Note that Data Catalog search queries do not guarantee full recall. Query" ] # [ doc = " results that match your query may not be returned, even in subsequent" ] # [ doc = " result pages. Also note that results returned (and not returned) can vary" ] # [ doc = " across repeated search queries." ] # [ doc = "" ] # [ doc = " See [Data Catalog Search" ] # [ doc = " Syntax](https://cloud.google.com/data-catalog/docs/how-to/search-reference)" ] # [ doc = " for more information." ] pub async fn search_catalog ( & mut self , request : impl tonic :: IntoRequest < super :: SearchCatalogRequest > , ) -> Result < tonic :: Response < super :: SearchCatalogResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/SearchCatalog" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates an EntryGroup." ] # [ doc = "" ] # [ doc = " An entry group contains logically related entries together with Cloud" ] # [ doc = " Identity and Access Management policies that specify the users who can" ] # [ doc = " create, edit, and view entries within the entry group." ] # [ doc = "" ] # [ doc = " Data Catalog automatically creates an entry group for BigQuery entries" ] # [ doc = " (\"@bigquery\") and Pub/Sub topics (\"@pubsub\"). Users create their own entry" ] # [ doc = " group to contain Cloud Storage fileset entries or custom type entries," ] # [ doc = " and the IAM policies associated with those entries. Entry groups, like" ] # [ doc = " entries, can be searched." ] # [ doc = "" ] # [ doc = " A maximum of 10,000 entry groups may be created per organization across all" ] # [ doc = " locations." ] # [ doc = "" ] # [ doc = " Users should enable the Data Catalog API in the project identified by" ] # [ doc = " the `parent` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn create_entry_group ( & mut self , request : impl tonic :: IntoRequest < super :: CreateEntryGroupRequest > , ) -> Result < tonic :: Response < super :: EntryGroup > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/CreateEntryGroup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an EntryGroup." ] pub async fn get_entry_group ( & mut self , request : impl tonic :: IntoRequest < super :: GetEntryGroupRequest > , ) -> Result < tonic :: Response < super :: EntryGroup > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/GetEntryGroup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an EntryGroup. The user should enable the Data Catalog API in the" ] # [ doc = " project identified by the `entry_group.name` parameter (see [Data Catalog" ] # [ doc = " Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn update_entry_group ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateEntryGroupRequest > , ) -> Result < tonic :: Response < super :: EntryGroup > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/UpdateEntryGroup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an EntryGroup. Only entry groups that do not contain entries can be" ] # [ doc = " deleted. Users should enable the Data Catalog API in the project" ] # [ doc = " identified by the `name` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn delete_entry_group ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteEntryGroupRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/DeleteEntryGroup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists entry groups." ] pub async fn list_entry_groups ( & mut self , request : impl tonic :: IntoRequest < super :: ListEntryGroupsRequest > , ) -> Result < tonic :: Response < super :: ListEntryGroupsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/ListEntryGroups" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates an entry. Only entries of 'FILESET' type or user-specified type can" ] # [ doc = " be created." ] # [ doc = "" ] # [ doc = " Users should enable the Data Catalog API in the project identified by" ] # [ doc = " the `parent` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] # [ doc = "" ] # [ doc = " A maximum of 100,000 entries may be created per entry group." ] pub async fn create_entry ( & mut self , request : impl tonic :: IntoRequest < super :: CreateEntryRequest > , ) -> Result < tonic :: Response < super :: Entry > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/CreateEntry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing entry." ] # [ doc = " Users should enable the Data Catalog API in the project identified by" ] # [ doc = " the `entry.name` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn update_entry ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateEntryRequest > , ) -> Result < tonic :: Response < super :: Entry > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/UpdateEntry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an existing entry. Only entries created through" ] # [ doc = " [CreateEntry][google.cloud.datacatalog.v1.DataCatalog.CreateEntry]" ] # [ doc = " method can be deleted." ] # [ doc = " Users should enable the Data Catalog API in the project identified by" ] # [ doc = " the `name` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn delete_entry ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteEntryRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/DeleteEntry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets an entry." ] pub async fn get_entry ( & mut self , request : impl tonic :: IntoRequest < super :: GetEntryRequest > , ) -> Result < tonic :: Response < super :: Entry > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/GetEntry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get an entry by target resource name. This method allows clients to use" ] # [ doc = " the resource name from the source Google Cloud Platform service to get the" ] # [ doc = " Data Catalog Entry." ] pub async fn lookup_entry ( & mut self , request : impl tonic :: IntoRequest < super :: LookupEntryRequest > , ) -> Result < tonic :: Response < super :: Entry > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/LookupEntry" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists entries." ] pub async fn list_entries ( & mut self , request : impl tonic :: IntoRequest < super :: ListEntriesRequest > , ) -> Result < tonic :: Response < super :: ListEntriesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/ListEntries" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a tag template. The user should enable the Data Catalog API in" ] # [ doc = " the project identified by the `parent` parameter (see [Data Catalog" ] # [ doc = " Resource" ] # [ doc = " Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project)" ] # [ doc = " for more information)." ] pub async fn create_tag_template ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTagTemplateRequest > , ) -> Result < tonic :: Response < super :: TagTemplate > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/CreateTagTemplate" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a tag template." ] pub async fn get_tag_template ( & mut self , request : impl tonic :: IntoRequest < super :: GetTagTemplateRequest > , ) -> Result < tonic :: Response < super :: TagTemplate > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/GetTagTemplate" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a tag template. This method cannot be used to update the fields of" ] # [ doc = " a template. The tag template fields are represented as separate resources" ] # [ doc = " and should be updated using their own create/update/delete methods." ] # [ doc = " Users should enable the Data Catalog API in the project identified by" ] # [ doc = " the `tag_template.name` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn update_tag_template ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateTagTemplateRequest > , ) -> Result < tonic :: Response < super :: TagTemplate > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/UpdateTagTemplate" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a tag template and all tags using the template." ] # [ doc = " Users should enable the Data Catalog API in the project identified by" ] # [ doc = " the `name` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn delete_tag_template ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTagTemplateRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/DeleteTagTemplate" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a field in a tag template. The user should enable the Data Catalog" ] # [ doc = " API in the project identified by the `parent` parameter (see" ] # [ doc = " [Data Catalog Resource" ] # [ doc = " Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project)" ] # [ doc = " for more information)." ] pub async fn create_tag_template_field ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTagTemplateFieldRequest > , ) -> Result < tonic :: Response < super :: TagTemplateField > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/CreateTagTemplateField" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a field in a tag template. This method cannot be used to update the" ] # [ doc = " field type. Users should enable the Data Catalog API in the project" ] # [ doc = " identified by the `name` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn update_tag_template_field ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateTagTemplateFieldRequest > , ) -> Result < tonic :: Response < super :: TagTemplateField > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/UpdateTagTemplateField" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Renames a field in a tag template. The user should enable the Data Catalog" ] # [ doc = " API in the project identified by the `name` parameter (see [Data Catalog" ] # [ doc = " Resource" ] # [ doc = " Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project)" ] # [ doc = " for more information)." ] pub async fn rename_tag_template_field ( & mut self , request : impl tonic :: IntoRequest < super :: RenameTagTemplateFieldRequest > , ) -> Result < tonic :: Response < super :: TagTemplateField > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/RenameTagTemplateField" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a field in a tag template and all uses of that field." ] # [ doc = " Users should enable the Data Catalog API in the project identified by" ] # [ doc = " the `name` parameter (see [Data Catalog Resource Project]" ] # [ doc = " (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for" ] # [ doc = " more information)." ] pub async fn delete_tag_template_field ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTagTemplateFieldRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/DeleteTagTemplateField" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a tag on an [Entry][google.cloud.datacatalog.v1.Entry]." ] # [ doc = " Note: The project identified by the `parent` parameter for the" ] # [ doc = " [tag](https://cloud.google.com/data-catalog/docs/reference/rest/v1/projects.locations.entryGroups.entries.tags/create#path-parameters)" ] # [ doc = " and the" ] # [ doc = " [tag" ] # [ doc = " template](https://cloud.google.com/data-catalog/docs/reference/rest/v1/projects.locations.tagTemplates/create#path-parameters)" ] # [ doc = " used to create the tag must be from the same organization." ] pub async fn create_tag ( & mut self , request : impl tonic :: IntoRequest < super :: CreateTagRequest > , ) -> Result < tonic :: Response < super :: Tag > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/CreateTag" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing tag." ] pub async fn update_tag ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateTagRequest > , ) -> Result < tonic :: Response < super :: Tag > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/UpdateTag" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a tag." ] pub async fn delete_tag ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTagRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/DeleteTag" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the tags on an [Entry][google.cloud.datacatalog.v1.Entry]." ] pub async fn list_tags ( & mut self , request : impl tonic :: IntoRequest < super :: ListTagsRequest > , ) -> Result < tonic :: Response < super :: ListTagsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/ListTags" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy for a resource. Replaces any existing" ] # [ doc = " policy." ] # [ doc = " Supported resources are:" ] # [ doc = " - Tag templates." ] # [ doc = " - Entries." ] # [ doc = " - Entry groups." ] # [ doc = " Note, this method cannot be used to manage policies for BigQuery, Pub/Sub" ] # [ doc = " and any external Google Cloud Platform resources synced to Data Catalog." ] # [ doc = "" ] # [ doc = " Callers must have following Google IAM permission" ] # [ doc = " - `datacatalog.tagTemplates.setIamPolicy` to set policies on tag" ] # [ doc = " templates." ] # [ doc = " - `datacatalog.entries.setIamPolicy` to set policies on entries." ] # [ doc = " - `datacatalog.entryGroups.setIamPolicy` to set policies on entry groups." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a resource. A `NOT_FOUND` error" ] # [ doc = " is returned if the resource does not exist. An empty policy is returned" ] # [ doc = " if the resource exists but does not have a policy set on it." ] # [ doc = "" ] # [ doc = " Supported resources are:" ] # [ doc = " - Tag templates." ] # [ doc = " - Entries." ] # [ doc = " - Entry groups." ] # [ doc = " Note, this method cannot be used to manage policies for BigQuery, Pub/Sub" ] # [ doc = " and any external Google Cloud Platform resources synced to Data Catalog." ] # [ doc = "" ] # [ doc = " Callers must have following Google IAM permission" ] # [ doc = " - `datacatalog.tagTemplates.getIamPolicy` to get policies on tag" ] # [ doc = " templates." ] # [ doc = " - `datacatalog.entries.getIamPolicy` to get policies on entries." ] # [ doc = " - `datacatalog.entryGroups.getIamPolicy` to get policies on entry groups." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the caller's permissions on a resource." ] # [ doc = " If the resource does not exist, an empty set of permissions is returned" ] # [ doc = " (We don't return a `NOT_FOUND` error)." ] # [ doc = "" ] # [ doc = " Supported resources are:" ] # [ doc = " - Tag templates." ] # [ doc = " - Entries." ] # [ doc = " - Entry groups." ] # [ doc = " Note, this method cannot be used to manage policies for BigQuery, Pub/Sub" ] # [ doc = " and any external Google Cloud Platform resources synced to Data Catalog." ] # [ doc = "" ] # [ doc = " A caller is not required to have Google IAM permission to make this" ] # [ doc = " request." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1.DataCatalog/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DataCatalogClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DataCatalogClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DataCatalogClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/datacatalog/v1beta1.rs:1441:3269 [INFO] [stdout] | [INFO] [stdout] 1441 | # [ doc = r" Generated client implementations." ] pub mod policy_tag_manager_serialization_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Policy tag manager serialization API service allows clients to manipulate" ] # [ doc = " their taxonomies and policy tags data with serialized format." ] pub struct PolicyTagManagerSerializationClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > PolicyTagManagerSerializationClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Imports all taxonomies and their policy tags to a project as new" ] # [ doc = " taxonomies." ] # [ doc = "" ] # [ doc = " This method provides a bulk taxonomy / policy tag creation using nested" ] # [ doc = " proto structure." ] pub async fn import_taxonomies ( & mut self , request : impl tonic :: IntoRequest < super :: ImportTaxonomiesRequest > , ) -> Result < tonic :: Response < super :: ImportTaxonomiesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1beta1.PolicyTagManagerSerialization/ImportTaxonomies" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Exports all taxonomies and their policy tags in a project." ] # [ doc = "" ] # [ doc = " This method generates SerializedTaxonomy protos with nested policy tags" ] # [ doc = " that can be used as an input for future ImportTaxonomies calls." ] pub async fn export_taxonomies ( & mut self , request : impl tonic :: IntoRequest < super :: ExportTaxonomiesRequest > , ) -> Result < tonic :: Response < super :: ExportTaxonomiesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.datacatalog.v1beta1.PolicyTagManagerSerialization/ExportTaxonomies" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for PolicyTagManagerSerializationClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for PolicyTagManagerSerializationClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "PolicyTagManagerSerializationClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/osconfig/v1beta.rs:1623:12110 [INFO] [stdout] | [INFO] [stdout] 1623 | # [ doc = r" Generated client implementations." ] pub mod os_config_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " OS Config API" ] # [ doc = "" ] # [ doc = " The OS Config service is a server-side component that you can use to" ] # [ doc = " manage package installations and patch jobs for virtual machine instances." ] pub struct OsConfigServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > OsConfigServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Patch VM instances by creating and running a patch job." ] pub async fn execute_patch_job ( & mut self , request : impl tonic :: IntoRequest < super :: ExecutePatchJobRequest > , ) -> Result < tonic :: Response < super :: PatchJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/ExecutePatchJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get the patch job. This can be used to track the progress of an" ] # [ doc = " ongoing patch job or review the details of completed jobs." ] pub async fn get_patch_job ( & mut self , request : impl tonic :: IntoRequest < super :: GetPatchJobRequest > , ) -> Result < tonic :: Response < super :: PatchJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/GetPatchJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Cancel a patch job. The patch job must be active. Canceled patch jobs" ] # [ doc = " cannot be restarted." ] pub async fn cancel_patch_job ( & mut self , request : impl tonic :: IntoRequest < super :: CancelPatchJobRequest > , ) -> Result < tonic :: Response < super :: PatchJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/CancelPatchJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get a list of patch jobs." ] pub async fn list_patch_jobs ( & mut self , request : impl tonic :: IntoRequest < super :: ListPatchJobsRequest > , ) -> Result < tonic :: Response < super :: ListPatchJobsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/ListPatchJobs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get a list of instance details for a given patch job." ] pub async fn list_patch_job_instance_details ( & mut self , request : impl tonic :: IntoRequest < super :: ListPatchJobInstanceDetailsRequest > , ) -> Result < tonic :: Response < super :: ListPatchJobInstanceDetailsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/ListPatchJobInstanceDetails" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create an OS Config patch deployment." ] pub async fn create_patch_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: CreatePatchDeploymentRequest > , ) -> Result < tonic :: Response < super :: PatchDeployment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/CreatePatchDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get an OS Config patch deployment." ] pub async fn get_patch_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: GetPatchDeploymentRequest > , ) -> Result < tonic :: Response < super :: PatchDeployment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/GetPatchDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get a page of OS Config patch deployments." ] pub async fn list_patch_deployments ( & mut self , request : impl tonic :: IntoRequest < super :: ListPatchDeploymentsRequest > , ) -> Result < tonic :: Response < super :: ListPatchDeploymentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/ListPatchDeployments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Delete an OS Config patch deployment." ] pub async fn delete_patch_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: DeletePatchDeploymentRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/DeletePatchDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create an OS Config guest policy." ] pub async fn create_guest_policy ( & mut self , request : impl tonic :: IntoRequest < super :: CreateGuestPolicyRequest > , ) -> Result < tonic :: Response < super :: GuestPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/CreateGuestPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get an OS Config guest policy." ] pub async fn get_guest_policy ( & mut self , request : impl tonic :: IntoRequest < super :: GetGuestPolicyRequest > , ) -> Result < tonic :: Response < super :: GuestPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/GetGuestPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get a page of OS Config guest policies." ] pub async fn list_guest_policies ( & mut self , request : impl tonic :: IntoRequest < super :: ListGuestPoliciesRequest > , ) -> Result < tonic :: Response < super :: ListGuestPoliciesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/ListGuestPolicies" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Update an OS Config guest policy." ] pub async fn update_guest_policy ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateGuestPolicyRequest > , ) -> Result < tonic :: Response < super :: GuestPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/UpdateGuestPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Delete an OS Config guest policy." ] pub async fn delete_guest_policy ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteGuestPolicyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/DeleteGuestPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lookup the effective guest policy that applies to a VM instance. This" ] # [ doc = " lookup merges all policies that are assigned to the instance ancestry." ] pub async fn lookup_effective_guest_policy ( & mut self , request : impl tonic :: IntoRequest < super :: LookupEffectiveGuestPolicyRequest > , ) -> Result < tonic :: Response < super :: EffectiveGuestPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1beta.OsConfigService/LookupEffectiveGuestPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for OsConfigServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for OsConfigServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "OsConfigServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/osconfig/v1.rs:846:7820 [INFO] [stdout] | [INFO] [stdout] 846 | # [ doc = r" Generated client implementations." ] pub mod os_config_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " OS Config API" ] # [ doc = "" ] # [ doc = " The OS Config service is a server-side component that you can use to" ] # [ doc = " manage package installations and patch jobs for virtual machine instances." ] pub struct OsConfigServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > OsConfigServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Patch VM instances by creating and running a patch job." ] pub async fn execute_patch_job ( & mut self , request : impl tonic :: IntoRequest < super :: ExecutePatchJobRequest > , ) -> Result < tonic :: Response < super :: PatchJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/ExecutePatchJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get the patch job. This can be used to track the progress of an" ] # [ doc = " ongoing patch job or review the details of completed jobs." ] pub async fn get_patch_job ( & mut self , request : impl tonic :: IntoRequest < super :: GetPatchJobRequest > , ) -> Result < tonic :: Response < super :: PatchJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/GetPatchJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Cancel a patch job. The patch job must be active. Canceled patch jobs" ] # [ doc = " cannot be restarted." ] pub async fn cancel_patch_job ( & mut self , request : impl tonic :: IntoRequest < super :: CancelPatchJobRequest > , ) -> Result < tonic :: Response < super :: PatchJob > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/CancelPatchJob" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get a list of patch jobs." ] pub async fn list_patch_jobs ( & mut self , request : impl tonic :: IntoRequest < super :: ListPatchJobsRequest > , ) -> Result < tonic :: Response < super :: ListPatchJobsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/ListPatchJobs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get a list of instance details for a given patch job." ] pub async fn list_patch_job_instance_details ( & mut self , request : impl tonic :: IntoRequest < super :: ListPatchJobInstanceDetailsRequest > , ) -> Result < tonic :: Response < super :: ListPatchJobInstanceDetailsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/ListPatchJobInstanceDetails" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create an OS Config patch deployment." ] pub async fn create_patch_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: CreatePatchDeploymentRequest > , ) -> Result < tonic :: Response < super :: PatchDeployment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/CreatePatchDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get an OS Config patch deployment." ] pub async fn get_patch_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: GetPatchDeploymentRequest > , ) -> Result < tonic :: Response < super :: PatchDeployment > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/GetPatchDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Get a page of OS Config patch deployments." ] pub async fn list_patch_deployments ( & mut self , request : impl tonic :: IntoRequest < super :: ListPatchDeploymentsRequest > , ) -> Result < tonic :: Response < super :: ListPatchDeploymentsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/ListPatchDeployments" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Delete an OS Config patch deployment." ] pub async fn delete_patch_deployment ( & mut self , request : impl tonic :: IntoRequest < super :: DeletePatchDeploymentRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.v1.OsConfigService/DeletePatchDeployment" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for OsConfigServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for OsConfigServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "OsConfigServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/osconfig/agentendpoint/v1beta.rs:1166:5915 [INFO] [stdout] | [INFO] [stdout] 1166 | # [ doc = r" Generated client implementations." ] pub mod agent_endpoint_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " OS Config agent endpoint API." ] pub struct AgentEndpointServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AgentEndpointServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Stream established by client to receive Task notifications." ] pub async fn receive_task_notification ( & mut self , request : impl tonic :: IntoRequest < super :: ReceiveTaskNotificationRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: ReceiveTaskNotificationResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1beta.AgentEndpointService/ReceiveTaskNotification" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signals the start of a task execution and returns the task info." ] pub async fn start_next_task ( & mut self , request : impl tonic :: IntoRequest < super :: StartNextTaskRequest > , ) -> Result < tonic :: Response < super :: StartNextTaskResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1beta.AgentEndpointService/StartNextTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signals an intermediary progress checkpoint in task execution." ] pub async fn report_task_progress ( & mut self , request : impl tonic :: IntoRequest < super :: ReportTaskProgressRequest > , ) -> Result < tonic :: Response < super :: ReportTaskProgressResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1beta.AgentEndpointService/ReportTaskProgress" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signals that the task execution is complete and optionally returns the next" ] # [ doc = " task." ] pub async fn report_task_complete ( & mut self , request : impl tonic :: IntoRequest < super :: ReportTaskCompleteRequest > , ) -> Result < tonic :: Response < super :: ReportTaskCompleteResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1beta.AgentEndpointService/ReportTaskComplete" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lookup the effective guest policy that applies to a VM instance. This" ] # [ doc = " lookup merges all policies that are assigned to the instance ancestry." ] pub async fn lookup_effective_guest_policy ( & mut self , request : impl tonic :: IntoRequest < super :: LookupEffectiveGuestPolicyRequest > , ) -> Result < tonic :: Response < super :: EffectiveGuestPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1beta.AgentEndpointService/LookupEffectiveGuestPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Registers the agent running on the VM." ] pub async fn register_agent ( & mut self , request : impl tonic :: IntoRequest < super :: RegisterAgentRequest > , ) -> Result < tonic :: Response < super :: RegisterAgentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1beta.AgentEndpointService/RegisterAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AgentEndpointServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AgentEndpointServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AgentEndpointServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/osconfig/agentendpoint/v1.rs:582:5033 [INFO] [stdout] | [INFO] [stdout] 582 | # [ doc = r" Generated client implementations." ] pub mod agent_endpoint_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " OS Config agent endpoint API." ] pub struct AgentEndpointServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AgentEndpointServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Stream established by client to receive Task notifications." ] pub async fn receive_task_notification ( & mut self , request : impl tonic :: IntoRequest < super :: ReceiveTaskNotificationRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: ReceiveTaskNotificationResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1.AgentEndpointService/ReceiveTaskNotification" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signals the start of a task execution and returns the task info." ] pub async fn start_next_task ( & mut self , request : impl tonic :: IntoRequest < super :: StartNextTaskRequest > , ) -> Result < tonic :: Response < super :: StartNextTaskResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1.AgentEndpointService/StartNextTask" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signals an intermediary progress checkpoint in task execution." ] pub async fn report_task_progress ( & mut self , request : impl tonic :: IntoRequest < super :: ReportTaskProgressRequest > , ) -> Result < tonic :: Response < super :: ReportTaskProgressResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1.AgentEndpointService/ReportTaskProgress" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Signals that the task execution is complete and optionally returns the next" ] # [ doc = " task." ] pub async fn report_task_complete ( & mut self , request : impl tonic :: IntoRequest < super :: ReportTaskCompleteRequest > , ) -> Result < tonic :: Response < super :: ReportTaskCompleteResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1.AgentEndpointService/ReportTaskComplete" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Registers the agent running on the VM." ] pub async fn register_agent ( & mut self , request : impl tonic :: IntoRequest < super :: RegisterAgentRequest > , ) -> Result < tonic :: Response < super :: RegisterAgentResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.osconfig.agentendpoint.v1.AgentEndpointService/RegisterAgent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AgentEndpointServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AgentEndpointServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AgentEndpointServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/billing/v1.rs:443:2712 [INFO] [stdout] | [INFO] [stdout] 443 | # [ doc = r" Generated client implementations." ] pub mod cloud_catalog_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " A catalog of Google Cloud Platform services and SKUs." ] # [ doc = " Provides pricing information and metadata on Google Cloud Platform services" ] # [ doc = " and SKUs." ] pub struct CloudCatalogClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > CloudCatalogClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists all public cloud services." ] pub async fn list_services ( & mut self , request : impl tonic :: IntoRequest < super :: ListServicesRequest > , ) -> Result < tonic :: Response < super :: ListServicesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.billing.v1.CloudCatalog/ListServices" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all publicly available SKUs for a given cloud service." ] pub async fn list_skus ( & mut self , request : impl tonic :: IntoRequest < super :: ListSkusRequest > , ) -> Result < tonic :: Response < super :: ListSkusResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.billing.v1.CloudCatalog/ListSkus" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for CloudCatalogClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for CloudCatalogClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "CloudCatalogClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/billing/budgets/v1beta1.rs:233:5748 [INFO] [stdout] | [INFO] [stdout] 233 | # [ doc = r" Generated client implementations." ] pub mod budget_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " BudgetService stores Cloud Billing budgets, which define a" ] # [ doc = " budget plan and rules to execute as we track spend against that plan." ] pub struct BudgetServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > BudgetServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new budget. See" ] # [ doc = " Quotas and limits" ] # [ doc = " for more information on the limits of the number of budgets you can create." ] pub async fn create_budget ( & mut self , request : impl tonic :: IntoRequest < super :: CreateBudgetRequest > , ) -> Result < tonic :: Response < super :: Budget > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.billing.budgets.v1beta1.BudgetService/CreateBudget" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a budget and returns the updated budget." ] # [ doc = "" ] # [ doc = " WARNING: There are some fields exposed on the Google Cloud Console that" ] # [ doc = " aren’t available on this API. Budget fields that are not exposed in" ] # [ doc = " this API will not be changed by this method." ] pub async fn update_budget ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateBudgetRequest > , ) -> Result < tonic :: Response < super :: Budget > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.billing.budgets.v1beta1.BudgetService/UpdateBudget" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a budget." ] # [ doc = "" ] # [ doc = " WARNING: There are some fields exposed on the Google Cloud Console that" ] # [ doc = " aren’t available on this API. When reading from the API, you will not" ] # [ doc = " see these fields in the return value, though they may have been set" ] # [ doc = " in the Cloud Console." ] pub async fn get_budget ( & mut self , request : impl tonic :: IntoRequest < super :: GetBudgetRequest > , ) -> Result < tonic :: Response < super :: Budget > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.billing.budgets.v1beta1.BudgetService/GetBudget" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns a list of budgets for a billing account." ] # [ doc = "" ] # [ doc = " WARNING: There are some fields exposed on the Google Cloud Console that" ] # [ doc = " aren’t available on this API. When reading from the API, you will not" ] # [ doc = " see these fields in the return value, though they may have been set" ] # [ doc = " in the Cloud Console." ] pub async fn list_budgets ( & mut self , request : impl tonic :: IntoRequest < super :: ListBudgetsRequest > , ) -> Result < tonic :: Response < super :: ListBudgetsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.billing.budgets.v1beta1.BudgetService/ListBudgets" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a budget. Returns successfully if already deleted." ] pub async fn delete_budget ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteBudgetRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.billing.budgets.v1beta1.BudgetService/DeleteBudget" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for BudgetServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for BudgetServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "BudgetServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/talent/v4beta1.rs:4745:2297 [INFO] [stdout] | [INFO] [stdout] 4745 | # [ doc = r" Generated client implementations." ] pub mod event_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " A service handles client event report." ] pub struct EventServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > EventServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Report events issued when end user interacts with customer's application" ] # [ doc = " that uses Cloud Talent Solution. You may inspect the created events in" ] # [ doc = " [self service" ] # [ doc = " tools](https://console.cloud.google.com/talent-solution/overview)." ] # [ doc = " [Learn" ] # [ doc = " more](https://cloud.google.com/talent-solution/docs/management-tools)" ] # [ doc = " about self service tools." ] pub async fn create_client_event ( & mut self , request : impl tonic :: IntoRequest < super :: CreateClientEventRequest > , ) -> Result < tonic :: Response < super :: ClientEvent > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.talent.v4beta1.EventService/CreateClientEvent" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for EventServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for EventServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "EventServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/mediatranslation/v1beta1.rs:179:2245 [INFO] [stdout] | [INFO] [stdout] 179 | # [ doc = r" Generated client implementations." ] pub mod speech_translation_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Provides translation from/to media types." ] pub struct SpeechTranslationServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SpeechTranslationServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Performs bidirectional streaming speech translation: receive results while" ] # [ doc = " sending audio. This method is only available via the gRPC API (not REST)." ] pub async fn streaming_translate_speech ( & mut self , request : impl tonic :: IntoStreamingRequest < Message = super :: StreamingTranslateSpeechRequest > ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: StreamingTranslateSpeechResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.mediatranslation.v1beta1.SpeechTranslationService/StreamingTranslateSpeech" ) ; self . inner . streaming ( request . into_streaming_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SpeechTranslationServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SpeechTranslationServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SpeechTranslationServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/dataproc/v1.rs:2614:5133 [INFO] [stdout] | [INFO] [stdout] 2614 | # [ doc = r" Generated client implementations." ] pub mod autoscaling_policy_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The API interface for managing autoscaling policies in the" ] # [ doc = " Dataproc API." ] pub struct AutoscalingPolicyServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AutoscalingPolicyServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates new autoscaling policy." ] pub async fn create_autoscaling_policy ( & mut self , request : impl tonic :: IntoRequest < super :: CreateAutoscalingPolicyRequest > , ) -> Result < tonic :: Response < super :: AutoscalingPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1.AutoscalingPolicyService/CreateAutoscalingPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates (replaces) autoscaling policy." ] # [ doc = "" ] # [ doc = " Disabled check for update_mask, because all updates will be full" ] # [ doc = " replacements." ] pub async fn update_autoscaling_policy ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateAutoscalingPolicyRequest > , ) -> Result < tonic :: Response < super :: AutoscalingPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1.AutoscalingPolicyService/UpdateAutoscalingPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves autoscaling policy." ] pub async fn get_autoscaling_policy ( & mut self , request : impl tonic :: IntoRequest < super :: GetAutoscalingPolicyRequest > , ) -> Result < tonic :: Response < super :: AutoscalingPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1.AutoscalingPolicyService/GetAutoscalingPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists autoscaling policies in the project." ] pub async fn list_autoscaling_policies ( & mut self , request : impl tonic :: IntoRequest < super :: ListAutoscalingPoliciesRequest > , ) -> Result < tonic :: Response < super :: ListAutoscalingPoliciesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1.AutoscalingPolicyService/ListAutoscalingPolicies" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an autoscaling policy. It is an error to delete an autoscaling" ] # [ doc = " policy that is in use by one or more clusters." ] pub async fn delete_autoscaling_policy ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAutoscalingPolicyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1.AutoscalingPolicyService/DeleteAutoscalingPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AutoscalingPolicyServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AutoscalingPolicyServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AutoscalingPolicyServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/dataproc/v1beta2.rs:2691:5164 [INFO] [stdout] | [INFO] [stdout] 2691 | # [ doc = r" Generated client implementations." ] pub mod autoscaling_policy_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The API interface for managing autoscaling policies in the" ] # [ doc = " Cloud Dataproc API." ] pub struct AutoscalingPolicyServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > AutoscalingPolicyServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates new autoscaling policy." ] pub async fn create_autoscaling_policy ( & mut self , request : impl tonic :: IntoRequest < super :: CreateAutoscalingPolicyRequest > , ) -> Result < tonic :: Response < super :: AutoscalingPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1beta2.AutoscalingPolicyService/CreateAutoscalingPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates (replaces) autoscaling policy." ] # [ doc = "" ] # [ doc = " Disabled check for update_mask, because all updates will be full" ] # [ doc = " replacements." ] pub async fn update_autoscaling_policy ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateAutoscalingPolicyRequest > , ) -> Result < tonic :: Response < super :: AutoscalingPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1beta2.AutoscalingPolicyService/UpdateAutoscalingPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Retrieves autoscaling policy." ] pub async fn get_autoscaling_policy ( & mut self , request : impl tonic :: IntoRequest < super :: GetAutoscalingPolicyRequest > , ) -> Result < tonic :: Response < super :: AutoscalingPolicy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1beta2.AutoscalingPolicyService/GetAutoscalingPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists autoscaling policies in the project." ] pub async fn list_autoscaling_policies ( & mut self , request : impl tonic :: IntoRequest < super :: ListAutoscalingPoliciesRequest > , ) -> Result < tonic :: Response < super :: ListAutoscalingPoliciesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1beta2.AutoscalingPolicyService/ListAutoscalingPolicies" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an autoscaling policy. It is an error to delete an autoscaling" ] # [ doc = " policy that is in use by one or more clusters." ] pub async fn delete_autoscaling_policy ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteAutoscalingPolicyRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.dataproc.v1beta2.AutoscalingPolicyService/DeleteAutoscalingPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for AutoscalingPolicyServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for AutoscalingPolicyServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "AutoscalingPolicyServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/managedidentities/v1.rs:372:10174 [INFO] [stdout] | [INFO] [stdout] 372 | # [ doc = r" Generated client implementations." ] pub mod managed_identities_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " ## API Overview" ] # [ doc = "" ] # [ doc = " The `managedidentites.googleapis.com` service implements the Google Cloud" ] # [ doc = " Managed Identites API for identity services" ] # [ doc = " (e.g. Microsoft Active Directory)." ] # [ doc = "" ] # [ doc = " The Managed Identities service provides methods to manage" ] # [ doc = " (create/read/update/delete) domains, reset managed identities admin password," ] # [ doc = " add/remove domain controllers in GCP regions and add/remove VPC peering." ] # [ doc = "" ] # [ doc = " ## Data Model" ] # [ doc = "" ] # [ doc = " The Managed Identities service exposes the following resources:" ] # [ doc = "" ] # [ doc = " * Locations as global, named as follows:" ] # [ doc = " `projects/{project_id}/locations/global`." ] # [ doc = "" ] # [ doc = " * Domains, named as follows:" ] # [ doc = " `/projects/{project_id}/locations/global/domain/{domain_name}`." ] # [ doc = "" ] # [ doc = " The `{domain_name}` refers to fully qualified domain name in the customer" ] # [ doc = " project e.g. mydomain.myorganization.com, with the following restrictions:" ] # [ doc = "" ] # [ doc = " * Must contain only lowercase letters, numbers, periods and hyphens." ] # [ doc = " * Must start with a letter." ] # [ doc = " * Must contain between 2-64 characters." ] # [ doc = " * Must end with a number or a letter." ] # [ doc = " * Must not start with period." ] # [ doc = " * First segement length (mydomain form example above) shouldn't exceed" ] # [ doc = " 15 chars." ] # [ doc = " * The last segment cannot be fully numeric." ] # [ doc = " * Must be unique within the customer project." ] pub struct ManagedIdentitiesServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ManagedIdentitiesServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a Microsoft AD domain." ] pub async fn create_microsoft_ad_domain ( & mut self , request : impl tonic :: IntoRequest < super :: CreateMicrosoftAdDomainRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/CreateMicrosoftAdDomain" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Resets a domain's administrator password." ] pub async fn reset_admin_password ( & mut self , request : impl tonic :: IntoRequest < super :: ResetAdminPasswordRequest > , ) -> Result < tonic :: Response < super :: ResetAdminPasswordResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/ResetAdminPassword" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists domains in a project." ] pub async fn list_domains ( & mut self , request : impl tonic :: IntoRequest < super :: ListDomainsRequest > , ) -> Result < tonic :: Response < super :: ListDomainsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/ListDomains" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a domain." ] pub async fn get_domain ( & mut self , request : impl tonic :: IntoRequest < super :: GetDomainRequest > , ) -> Result < tonic :: Response < super :: Domain > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/GetDomain" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the metadata and configuration of a domain." ] pub async fn update_domain ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateDomainRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/UpdateDomain" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a domain." ] pub async fn delete_domain ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteDomainRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/DeleteDomain" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Adds an AD trust to a domain." ] pub async fn attach_trust ( & mut self , request : impl tonic :: IntoRequest < super :: AttachTrustRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/AttachTrust" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the DNS conditional forwarder." ] pub async fn reconfigure_trust ( & mut self , request : impl tonic :: IntoRequest < super :: ReconfigureTrustRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/ReconfigureTrust" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Removes an AD trust." ] pub async fn detach_trust ( & mut self , request : impl tonic :: IntoRequest < super :: DetachTrustRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/DetachTrust" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Validates a trust state, that the target domain is reachable, and that the" ] # [ doc = " target domain is able to accept incoming trust requests." ] pub async fn validate_trust ( & mut self , request : impl tonic :: IntoRequest < super :: ValidateTrustRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1.ManagedIdentitiesService/ValidateTrust" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ManagedIdentitiesServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ManagedIdentitiesServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ManagedIdentitiesServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/cloud/managedidentities/v1beta1.rs:373:8572 [INFO] [stdout] | [INFO] [stdout] 373 | # [ doc = r" Generated client implementations." ] pub mod managed_identities_service_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; pub struct ManagedIdentitiesServiceClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > ManagedIdentitiesServiceClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a Microsoft AD domain." ] pub async fn create_microsoft_ad_domain ( & mut self , request : impl tonic :: IntoRequest < super :: CreateMicrosoftAdDomainRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/CreateMicrosoftAdDomain" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Resets a domain's administrator password." ] pub async fn reset_admin_password ( & mut self , request : impl tonic :: IntoRequest < super :: ResetAdminPasswordRequest > , ) -> Result < tonic :: Response < super :: ResetAdminPasswordResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/ResetAdminPassword" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists domains in a project." ] pub async fn list_domains ( & mut self , request : impl tonic :: IntoRequest < super :: ListDomainsRequest > , ) -> Result < tonic :: Response < super :: ListDomainsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/ListDomains" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a domain." ] pub async fn get_domain ( & mut self , request : impl tonic :: IntoRequest < super :: GetDomainRequest > , ) -> Result < tonic :: Response < super :: Domain > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/GetDomain" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the metadata and configuration of a domain." ] pub async fn update_domain ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateDomainRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/UpdateDomain" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a domain." ] pub async fn delete_domain ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteDomainRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/DeleteDomain" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Adds an AD trust to a domain." ] pub async fn attach_trust ( & mut self , request : impl tonic :: IntoRequest < super :: AttachTrustRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/AttachTrust" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the DNS conditional forwarder." ] pub async fn reconfigure_trust ( & mut self , request : impl tonic :: IntoRequest < super :: ReconfigureTrustRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/ReconfigureTrust" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Removes an AD trust." ] pub async fn detach_trust ( & mut self , request : impl tonic :: IntoRequest < super :: DetachTrustRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/DetachTrust" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Validates a trust state, that the target domain is reachable, and that the" ] # [ doc = " target domain is able to accept incoming trust requests." ] pub async fn validate_trust ( & mut self , request : impl tonic :: IntoRequest < super :: ValidateTrustRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.cloud.managedidentities.v1beta1.ManagedIdentitiesService/ValidateTrust" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for ManagedIdentitiesServiceClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for ManagedIdentitiesServiceClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "ManagedIdentitiesServiceClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/pubsub/v1.rs:841:26135 [INFO] [stdout] | [INFO] [stdout] 841 | # [ doc = r" Generated client implementations." ] pub mod publisher_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The service that an application uses to manipulate topics, and to send" ] # [ doc = " messages to a topic." ] pub struct PublisherClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > PublisherClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates the given topic with the given name. See the" ] # [ doc = " " ] # [ doc = " resource name rules." ] pub async fn create_topic ( & mut self , request : impl tonic :: IntoRequest < super :: Topic > , ) -> Result < tonic :: Response < super :: Topic > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Publisher/CreateTopic" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing topic. Note that certain properties of a" ] # [ doc = " topic are not modifiable." ] pub async fn update_topic ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateTopicRequest > , ) -> Result < tonic :: Response < super :: Topic > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Publisher/UpdateTopic" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Adds one or more messages to the topic. Returns `NOT_FOUND` if the topic" ] # [ doc = " does not exist." ] pub async fn publish ( & mut self , request : impl tonic :: IntoRequest < super :: PublishRequest > , ) -> Result < tonic :: Response < super :: PublishResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Publisher/Publish" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the configuration of a topic." ] pub async fn get_topic ( & mut self , request : impl tonic :: IntoRequest < super :: GetTopicRequest > , ) -> Result < tonic :: Response < super :: Topic > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Publisher/GetTopic" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists matching topics." ] pub async fn list_topics ( & mut self , request : impl tonic :: IntoRequest < super :: ListTopicsRequest > , ) -> Result < tonic :: Response < super :: ListTopicsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Publisher/ListTopics" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the names of the subscriptions on this topic." ] pub async fn list_topic_subscriptions ( & mut self , request : impl tonic :: IntoRequest < super :: ListTopicSubscriptionsRequest > , ) -> Result < tonic :: Response < super :: ListTopicSubscriptionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Publisher/ListTopicSubscriptions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the names of the snapshots on this topic. Snapshots are used in" ] # [ doc = " Seek" ] # [ doc = " operations, which allow" ] # [ doc = " you to manage message acknowledgments in bulk. That is, you can set the" ] # [ doc = " acknowledgment state of messages in an existing subscription to the state" ] # [ doc = " captured by a snapshot." ] pub async fn list_topic_snapshots ( & mut self , request : impl tonic :: IntoRequest < super :: ListTopicSnapshotsRequest > , ) -> Result < tonic :: Response < super :: ListTopicSnapshotsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Publisher/ListTopicSnapshots" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the topic with the given name. Returns `NOT_FOUND` if the topic" ] # [ doc = " does not exist. After a topic is deleted, a new topic may be created with" ] # [ doc = " the same name; this is an entirely new topic with none of the old" ] # [ doc = " configuration or subscriptions. Existing subscriptions to this topic are" ] # [ doc = " not deleted, but their `topic` field is set to `_deleted-topic_`." ] pub async fn delete_topic ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTopicRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Publisher/DeleteTopic" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for PublisherClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for PublisherClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "PublisherClient {{ ... }}" ) } } } # [ doc = r" Generated client implementations." ] pub mod subscriber_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The service that an application uses to manipulate subscriptions and to" ] # [ doc = " consume messages from a subscription via the `Pull` method or by" ] # [ doc = " establishing a bi-directional stream using the `StreamingPull` method." ] pub struct SubscriberClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SubscriberClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a subscription to a given topic. See the" ] # [ doc = " " ] # [ doc = " resource name rules." ] # [ doc = " If the subscription already exists, returns `ALREADY_EXISTS`." ] # [ doc = " If the corresponding topic doesn't exist, returns `NOT_FOUND`." ] # [ doc = "" ] # [ doc = " If the name is not provided in the request, the server will assign a random" ] # [ doc = " name for this subscription on the same project as the topic, conforming" ] # [ doc = " to the" ] # [ doc = " [resource name" ] # [ doc = " format](https://cloud.google.com/pubsub/docs/admin#resource_names). The" ] # [ doc = " generated name is populated in the returned Subscription object. Note that" ] # [ doc = " for REST API requests, you must specify a name in the request." ] pub async fn create_subscription ( & mut self , request : impl tonic :: IntoRequest < super :: Subscription > , ) -> Result < tonic :: Response < super :: Subscription > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/CreateSubscription" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the configuration details of a subscription." ] pub async fn get_subscription ( & mut self , request : impl tonic :: IntoRequest < super :: GetSubscriptionRequest > , ) -> Result < tonic :: Response < super :: Subscription > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/GetSubscription" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing subscription. Note that certain properties of a" ] # [ doc = " subscription, such as its topic, are not modifiable." ] pub async fn update_subscription ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateSubscriptionRequest > , ) -> Result < tonic :: Response < super :: Subscription > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/UpdateSubscription" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists matching subscriptions." ] pub async fn list_subscriptions ( & mut self , request : impl tonic :: IntoRequest < super :: ListSubscriptionsRequest > , ) -> Result < tonic :: Response < super :: ListSubscriptionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/ListSubscriptions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an existing subscription. All messages retained in the subscription" ] # [ doc = " are immediately dropped. Calls to `Pull` after deletion will return" ] # [ doc = " `NOT_FOUND`. After a subscription is deleted, a new one may be created with" ] # [ doc = " the same name, but the new one has no association with the old" ] # [ doc = " subscription or its topic unless the same topic is specified." ] pub async fn delete_subscription ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSubscriptionRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/DeleteSubscription" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Modifies the ack deadline for a specific message. This method is useful" ] # [ doc = " to indicate that more time is needed to process a message by the" ] # [ doc = " subscriber, or to make the message available for redelivery if the" ] # [ doc = " processing was interrupted. Note that this does not modify the" ] # [ doc = " subscription-level `ackDeadlineSeconds` used for subsequent messages." ] pub async fn modify_ack_deadline ( & mut self , request : impl tonic :: IntoRequest < super :: ModifyAckDeadlineRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/ModifyAckDeadline" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Acknowledges the messages associated with the `ack_ids` in the" ] # [ doc = " `AcknowledgeRequest`. The Pub/Sub system can remove the relevant messages" ] # [ doc = " from the subscription." ] # [ doc = "" ] # [ doc = " Acknowledging a message whose ack deadline has expired may succeed," ] # [ doc = " but such a message may be redelivered later. Acknowledging a message more" ] # [ doc = " than once will not result in an error." ] pub async fn acknowledge ( & mut self , request : impl tonic :: IntoRequest < super :: AcknowledgeRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/Acknowledge" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Pulls messages from the server. The server may return `UNAVAILABLE` if" ] # [ doc = " there are too many concurrent pull requests pending for the given" ] # [ doc = " subscription." ] pub async fn pull ( & mut self , request : impl tonic :: IntoRequest < super :: PullRequest > , ) -> Result < tonic :: Response < super :: PullResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/Pull" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Establishes a stream with the server, which sends messages down to the" ] # [ doc = " client. The client streams acknowledgements and ack deadline modifications" ] # [ doc = " back to the server. The server will close the stream and return the status" ] # [ doc = " on any error. The server may close the stream with status `UNAVAILABLE` to" ] # [ doc = " reassign server-side resources, in which case, the client should" ] # [ doc = " re-establish the stream. Flow control can be achieved by configuring the" ] # [ doc = " underlying RPC channel." ] pub async fn streaming_pull ( & mut self , request : impl tonic :: IntoStreamingRequest < Message = super :: StreamingPullRequest > ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: StreamingPullResponse >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/StreamingPull" ) ; self . inner . streaming ( request . into_streaming_request ( ) , path , codec ) . await } # [ doc = " Modifies the `PushConfig` for a specified subscription." ] # [ doc = "" ] # [ doc = " This may be used to change a push subscription to a pull one (signified by" ] # [ doc = " an empty `PushConfig`) or vice versa, or change the endpoint URL and other" ] # [ doc = " attributes of a push subscription. Messages will accumulate for delivery" ] # [ doc = " continuously through the call regardless of changes to the `PushConfig`." ] pub async fn modify_push_config ( & mut self , request : impl tonic :: IntoRequest < super :: ModifyPushConfigRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/ModifyPushConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the configuration details of a snapshot. Snapshots are used in" ] # [ doc = " Seek" ] # [ doc = " operations, which allow you to manage message acknowledgments in bulk. That" ] # [ doc = " is, you can set the acknowledgment state of messages in an existing" ] # [ doc = " subscription to the state captured by a snapshot." ] pub async fn get_snapshot ( & mut self , request : impl tonic :: IntoRequest < super :: GetSnapshotRequest > , ) -> Result < tonic :: Response < super :: Snapshot > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/GetSnapshot" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the existing snapshots. Snapshots are used in" ] # [ doc = " Seek" ] # [ doc = " operations, which allow" ] # [ doc = " you to manage message acknowledgments in bulk. That is, you can set the" ] # [ doc = " acknowledgment state of messages in an existing subscription to the state" ] # [ doc = " captured by a snapshot." ] pub async fn list_snapshots ( & mut self , request : impl tonic :: IntoRequest < super :: ListSnapshotsRequest > , ) -> Result < tonic :: Response < super :: ListSnapshotsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/ListSnapshots" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a snapshot from the requested subscription. Snapshots are used in" ] # [ doc = " Seek" ] # [ doc = " operations, which allow" ] # [ doc = " you to manage message acknowledgments in bulk. That is, you can set the" ] # [ doc = " acknowledgment state of messages in an existing subscription to the state" ] # [ doc = " captured by a snapshot." ] # [ doc = "

If the snapshot already exists, returns `ALREADY_EXISTS`." ] # [ doc = " If the requested subscription doesn't exist, returns `NOT_FOUND`." ] # [ doc = " If the backlog in the subscription is too old -- and the resulting snapshot" ] # [ doc = " would expire in less than 1 hour -- then `FAILED_PRECONDITION` is returned." ] # [ doc = " See also the `Snapshot.expire_time` field. If the name is not provided in" ] # [ doc = " the request, the server will assign a random" ] # [ doc = " name for this snapshot on the same project as the subscription, conforming" ] # [ doc = " to the" ] # [ doc = " [resource name" ] # [ doc = " format](https://cloud.google.com/pubsub/docs/admin#resource_names). The" ] # [ doc = " generated name is populated in the returned Snapshot object. Note that for" ] # [ doc = " REST API requests, you must specify a name in the request." ] pub async fn create_snapshot ( & mut self , request : impl tonic :: IntoRequest < super :: CreateSnapshotRequest > , ) -> Result < tonic :: Response < super :: Snapshot > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/CreateSnapshot" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an existing snapshot. Snapshots are used in" ] # [ doc = " Seek" ] # [ doc = " operations, which allow" ] # [ doc = " you to manage message acknowledgments in bulk. That is, you can set the" ] # [ doc = " acknowledgment state of messages in an existing subscription to the state" ] # [ doc = " captured by a snapshot." ] pub async fn update_snapshot ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateSnapshotRequest > , ) -> Result < tonic :: Response < super :: Snapshot > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/UpdateSnapshot" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Removes an existing snapshot. Snapshots are used in" ] # [ doc = " Seek" ] # [ doc = " operations, which allow" ] # [ doc = " you to manage message acknowledgments in bulk. That is, you can set the" ] # [ doc = " acknowledgment state of messages in an existing subscription to the state" ] # [ doc = " captured by a snapshot.

" ] # [ doc = " When the snapshot is deleted, all messages retained in the snapshot" ] # [ doc = " are immediately dropped. After a snapshot is deleted, a new one may be" ] # [ doc = " created with the same name, but the new one has no association with the old" ] # [ doc = " snapshot or its subscription, unless the same subscription is specified." ] pub async fn delete_snapshot ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSnapshotRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/DeleteSnapshot" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Seeks an existing subscription to a point in time or to a given snapshot," ] # [ doc = " whichever is provided in the request. Snapshots are used in" ] # [ doc = " Seek" ] # [ doc = " operations, which allow" ] # [ doc = " you to manage message acknowledgments in bulk. That is, you can set the" ] # [ doc = " acknowledgment state of messages in an existing subscription to the state" ] # [ doc = " captured by a snapshot. Note that both the subscription and the snapshot" ] # [ doc = " must be on the same topic." ] pub async fn seek ( & mut self , request : impl tonic :: IntoRequest < super :: SeekRequest > , ) -> Result < tonic :: Response < super :: SeekResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1.Subscriber/Seek" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SubscriberClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SubscriberClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SubscriberClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/pubsub/v1beta2.rs:300:14171 [INFO] [stdout] | [INFO] [stdout] 300 | # [ doc = r" Generated client implementations." ] pub mod subscriber_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The service that an application uses to manipulate subscriptions and to" ] # [ doc = " consume messages from a subscription via the Pull method." ] pub struct SubscriberClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SubscriberClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a subscription to a given topic for a given subscriber." ] # [ doc = " If the subscription already exists, returns ALREADY_EXISTS." ] # [ doc = " If the corresponding topic doesn't exist, returns NOT_FOUND." ] # [ doc = "" ] # [ doc = " If the name is not provided in the request, the server will assign a random" ] # [ doc = " name for this subscription on the same project as the topic." ] pub async fn create_subscription ( & mut self , request : impl tonic :: IntoRequest < super :: Subscription > , ) -> Result < tonic :: Response < super :: Subscription > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Subscriber/CreateSubscription" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the configuration details of a subscription." ] pub async fn get_subscription ( & mut self , request : impl tonic :: IntoRequest < super :: GetSubscriptionRequest > , ) -> Result < tonic :: Response < super :: Subscription > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Subscriber/GetSubscription" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists matching subscriptions." ] pub async fn list_subscriptions ( & mut self , request : impl tonic :: IntoRequest < super :: ListSubscriptionsRequest > , ) -> Result < tonic :: Response < super :: ListSubscriptionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Subscriber/ListSubscriptions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an existing subscription. All pending messages in the subscription" ] # [ doc = " are immediately dropped. Calls to Pull after deletion will return" ] # [ doc = " NOT_FOUND. After a subscription is deleted, a new one may be created with" ] # [ doc = " the same name, but the new one has no association with the old" ] # [ doc = " subscription, or its topic unless the same topic is specified." ] pub async fn delete_subscription ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSubscriptionRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Subscriber/DeleteSubscription" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Modifies the ack deadline for a specific message. This method is useful to" ] # [ doc = " indicate that more time is needed to process a message by the subscriber," ] # [ doc = " or to make the message available for redelivery if the processing was" ] # [ doc = " interrupted." ] pub async fn modify_ack_deadline ( & mut self , request : impl tonic :: IntoRequest < super :: ModifyAckDeadlineRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Subscriber/ModifyAckDeadline" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Acknowledges the messages associated with the ack tokens in the" ] # [ doc = " AcknowledgeRequest. The Pub/Sub system can remove the relevant messages" ] # [ doc = " from the subscription." ] # [ doc = "" ] # [ doc = " Acknowledging a message whose ack deadline has expired may succeed," ] # [ doc = " but such a message may be redelivered later. Acknowledging a message more" ] # [ doc = " than once will not result in an error." ] pub async fn acknowledge ( & mut self , request : impl tonic :: IntoRequest < super :: AcknowledgeRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Subscriber/Acknowledge" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Pulls messages from the server. Returns an empty list if there are no" ] # [ doc = " messages available in the backlog. The server may return UNAVAILABLE if" ] # [ doc = " there are too many concurrent pull requests pending for the given" ] # [ doc = " subscription." ] pub async fn pull ( & mut self , request : impl tonic :: IntoRequest < super :: PullRequest > , ) -> Result < tonic :: Response < super :: PullResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Subscriber/Pull" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Modifies the PushConfig for a specified subscription." ] # [ doc = "" ] # [ doc = " This may be used to change a push subscription to a pull one (signified" ] # [ doc = " by an empty PushConfig) or vice versa, or change the endpoint URL and other" ] # [ doc = " attributes of a push subscription. Messages will accumulate for" ] # [ doc = " delivery continuously through the call regardless of changes to the" ] # [ doc = " PushConfig." ] pub async fn modify_push_config ( & mut self , request : impl tonic :: IntoRequest < super :: ModifyPushConfigRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Subscriber/ModifyPushConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SubscriberClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SubscriberClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SubscriberClient {{ ... }}" ) } } } # [ doc = r" Generated client implementations." ] pub mod publisher_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " The service that an application uses to manipulate topics, and to send" ] # [ doc = " messages to a topic." ] pub struct PublisherClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > PublisherClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates the given topic with the given name." ] pub async fn create_topic ( & mut self , request : impl tonic :: IntoRequest < super :: Topic > , ) -> Result < tonic :: Response < super :: Topic > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Publisher/CreateTopic" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Adds one or more messages to the topic. Returns NOT_FOUND if the topic does" ] # [ doc = " not exist." ] pub async fn publish ( & mut self , request : impl tonic :: IntoRequest < super :: PublishRequest > , ) -> Result < tonic :: Response < super :: PublishResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Publisher/Publish" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the configuration of a topic." ] pub async fn get_topic ( & mut self , request : impl tonic :: IntoRequest < super :: GetTopicRequest > , ) -> Result < tonic :: Response < super :: Topic > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Publisher/GetTopic" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists matching topics." ] pub async fn list_topics ( & mut self , request : impl tonic :: IntoRequest < super :: ListTopicsRequest > , ) -> Result < tonic :: Response < super :: ListTopicsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Publisher/ListTopics" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the name of the subscriptions for this topic." ] pub async fn list_topic_subscriptions ( & mut self , request : impl tonic :: IntoRequest < super :: ListTopicSubscriptionsRequest > , ) -> Result < tonic :: Response < super :: ListTopicSubscriptionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Publisher/ListTopicSubscriptions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes the topic with the given name. Returns NOT_FOUND if the topic does" ] # [ doc = " not exist. After a topic is deleted, a new topic may be created with the" ] # [ doc = " same name; this is an entirely new topic with none of the old" ] # [ doc = " configuration or subscriptions. Existing subscriptions to this topic are" ] # [ doc = " not deleted." ] pub async fn delete_topic ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteTopicRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.pubsub.v1beta2.Publisher/DeleteTopic" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for PublisherClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for PublisherClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "PublisherClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/spanner/v1.rs:1647:18761 [INFO] [stdout] | [INFO] [stdout] 1647 | # [ doc = r" Generated client implementations." ] pub mod spanner_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud Spanner API" ] # [ doc = "" ] # [ doc = " The Cloud Spanner API can be used to manage sessions and execute" ] # [ doc = " transactions on data stored in Cloud Spanner databases." ] pub struct SpannerClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > SpannerClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Creates a new session. A session can be used to perform" ] # [ doc = " transactions that read and/or modify data in a Cloud Spanner database." ] # [ doc = " Sessions are meant to be reused for many consecutive" ] # [ doc = " transactions." ] # [ doc = "" ] # [ doc = " Sessions can only execute one transaction at a time. To execute" ] # [ doc = " multiple concurrent read-write/write-only transactions, create" ] # [ doc = " multiple sessions. Note that standalone reads and queries use a" ] # [ doc = " transaction internally, and count toward the one transaction" ] # [ doc = " limit." ] # [ doc = "" ] # [ doc = " Active sessions use additional server resources, so it is a good idea to" ] # [ doc = " delete idle and unneeded sessions." ] # [ doc = " Aside from explicit deletes, Cloud Spanner may delete sessions for which no" ] # [ doc = " operations are sent for more than an hour. If a session is deleted," ] # [ doc = " requests to it return `NOT_FOUND`." ] # [ doc = "" ] # [ doc = " Idle sessions can be kept alive by sending a trivial SQL query" ] # [ doc = " periodically, e.g., `\"SELECT 1\"`." ] pub async fn create_session ( & mut self , request : impl tonic :: IntoRequest < super :: CreateSessionRequest > , ) -> Result < tonic :: Response < super :: Session > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/CreateSession" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates multiple new sessions." ] # [ doc = "" ] # [ doc = " This API can be used to initialize a session cache on the clients." ] # [ doc = " See https://goo.gl/TgSFN2 for best practices on session cache management." ] pub async fn batch_create_sessions ( & mut self , request : impl tonic :: IntoRequest < super :: BatchCreateSessionsRequest > , ) -> Result < tonic :: Response < super :: BatchCreateSessionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/BatchCreateSessions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets a session. Returns `NOT_FOUND` if the session does not exist." ] # [ doc = " This is mainly useful for determining whether a session is still" ] # [ doc = " alive." ] pub async fn get_session ( & mut self , request : impl tonic :: IntoRequest < super :: GetSessionRequest > , ) -> Result < tonic :: Response < super :: Session > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/GetSession" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all sessions in a given database." ] pub async fn list_sessions ( & mut self , request : impl tonic :: IntoRequest < super :: ListSessionsRequest > , ) -> Result < tonic :: Response < super :: ListSessionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/ListSessions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Ends a session, releasing server resources associated with it. This will" ] # [ doc = " asynchronously trigger cancellation of any operations that are running with" ] # [ doc = " this session." ] pub async fn delete_session ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteSessionRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/DeleteSession" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Executes an SQL statement, returning all results in a single reply. This" ] # [ doc = " method cannot be used to return a result set larger than 10 MiB;" ] # [ doc = " if the query yields more data than that, the query fails with" ] # [ doc = " a `FAILED_PRECONDITION` error." ] # [ doc = "" ] # [ doc = " Operations inside read-write transactions might return `ABORTED`. If" ] # [ doc = " this occurs, the application should restart the transaction from" ] # [ doc = " the beginning. See [Transaction][google.spanner.v1.Transaction] for more details." ] # [ doc = "" ] # [ doc = " Larger result sets can be fetched in streaming fashion by calling" ] # [ doc = " [ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStreamingSql] instead." ] pub async fn execute_sql ( & mut self , request : impl tonic :: IntoRequest < super :: ExecuteSqlRequest > , ) -> Result < tonic :: Response < super :: ResultSet > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/ExecuteSql" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Like [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql], except returns the result" ] # [ doc = " set as a stream. Unlike [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql], there" ] # [ doc = " is no limit on the size of the returned result set. However, no" ] # [ doc = " individual row in the result set can exceed 100 MiB, and no" ] # [ doc = " column value can exceed 10 MiB." ] pub async fn execute_streaming_sql ( & mut self , request : impl tonic :: IntoRequest < super :: ExecuteSqlRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: PartialResultSet >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/ExecuteStreamingSql" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Executes a batch of SQL DML statements. This method allows many statements" ] # [ doc = " to be run with lower latency than submitting them sequentially with" ] # [ doc = " [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql]." ] # [ doc = "" ] # [ doc = " Statements are executed in sequential order. A request can succeed even if" ] # [ doc = " a statement fails. The [ExecuteBatchDmlResponse.status][google.spanner.v1.ExecuteBatchDmlResponse.status] field in the" ] # [ doc = " response provides information about the statement that failed. Clients must" ] # [ doc = " inspect this field to determine whether an error occurred." ] # [ doc = "" ] # [ doc = " Execution stops after the first failed statement; the remaining statements" ] # [ doc = " are not executed." ] pub async fn execute_batch_dml ( & mut self , request : impl tonic :: IntoRequest < super :: ExecuteBatchDmlRequest > , ) -> Result < tonic :: Response < super :: ExecuteBatchDmlResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/ExecuteBatchDml" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Reads rows from the database using key lookups and scans, as a" ] # [ doc = " simple key/value style alternative to" ] # [ doc = " [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql]. This method cannot be used to" ] # [ doc = " return a result set larger than 10 MiB; if the read matches more" ] # [ doc = " data than that, the read fails with a `FAILED_PRECONDITION`" ] # [ doc = " error." ] # [ doc = "" ] # [ doc = " Reads inside read-write transactions might return `ABORTED`. If" ] # [ doc = " this occurs, the application should restart the transaction from" ] # [ doc = " the beginning. See [Transaction][google.spanner.v1.Transaction] for more details." ] # [ doc = "" ] # [ doc = " Larger result sets can be yielded in streaming fashion by calling" ] # [ doc = " [StreamingRead][google.spanner.v1.Spanner.StreamingRead] instead." ] pub async fn read ( & mut self , request : impl tonic :: IntoRequest < super :: ReadRequest > , ) -> Result < tonic :: Response < super :: ResultSet > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/Read" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Like [Read][google.spanner.v1.Spanner.Read], except returns the result set as a" ] # [ doc = " stream. Unlike [Read][google.spanner.v1.Spanner.Read], there is no limit on the" ] # [ doc = " size of the returned result set. However, no individual row in" ] # [ doc = " the result set can exceed 100 MiB, and no column value can exceed" ] # [ doc = " 10 MiB." ] pub async fn streaming_read ( & mut self , request : impl tonic :: IntoRequest < super :: ReadRequest > , ) -> Result < tonic :: Response < tonic :: codec :: Streaming < super :: PartialResultSet >> , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/StreamingRead" ) ; self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await } # [ doc = " Begins a new transaction. This step can often be skipped:" ] # [ doc = " [Read][google.spanner.v1.Spanner.Read], [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql] and" ] # [ doc = " [Commit][google.spanner.v1.Spanner.Commit] can begin a new transaction as a" ] # [ doc = " side-effect." ] pub async fn begin_transaction ( & mut self , request : impl tonic :: IntoRequest < super :: BeginTransactionRequest > , ) -> Result < tonic :: Response < super :: Transaction > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/BeginTransaction" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Commits a transaction. The request includes the mutations to be" ] # [ doc = " applied to rows in the database." ] # [ doc = "" ] # [ doc = " `Commit` might return an `ABORTED` error. This can occur at any time;" ] # [ doc = " commonly, the cause is conflicts with concurrent" ] # [ doc = " transactions. However, it can also happen for a variety of other" ] # [ doc = " reasons. If `Commit` returns `ABORTED`, the caller should re-attempt" ] # [ doc = " the transaction from the beginning, re-using the same session." ] pub async fn commit ( & mut self , request : impl tonic :: IntoRequest < super :: CommitRequest > , ) -> Result < tonic :: Response < super :: CommitResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/Commit" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Rolls back a transaction, releasing any locks it holds. It is a good" ] # [ doc = " idea to call this for any transaction that includes one or more" ] # [ doc = " [Read][google.spanner.v1.Spanner.Read] or [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql] requests and" ] # [ doc = " ultimately decides not to commit." ] # [ doc = "" ] # [ doc = " `Rollback` returns `OK` if it successfully aborts the transaction, the" ] # [ doc = " transaction was already aborted, or the transaction is not" ] # [ doc = " found. `Rollback` never returns `ABORTED`." ] pub async fn rollback ( & mut self , request : impl tonic :: IntoRequest < super :: RollbackRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/Rollback" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a set of partition tokens that can be used to execute a query" ] # [ doc = " operation in parallel. Each of the returned partition tokens can be used" ] # [ doc = " by [ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStreamingSql] to specify a subset" ] # [ doc = " of the query result to read. The same session and read-only transaction" ] # [ doc = " must be used by the PartitionQueryRequest used to create the" ] # [ doc = " partition tokens and the ExecuteSqlRequests that use the partition tokens." ] # [ doc = "" ] # [ doc = " Partition tokens become invalid when the session used to create them" ] # [ doc = " is deleted, is idle for too long, begins a new transaction, or becomes too" ] # [ doc = " old. When any of these happen, it is not possible to resume the query, and" ] # [ doc = " the whole operation must be restarted from the beginning." ] pub async fn partition_query ( & mut self , request : impl tonic :: IntoRequest < super :: PartitionQueryRequest > , ) -> Result < tonic :: Response < super :: PartitionResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/PartitionQuery" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a set of partition tokens that can be used to execute a read" ] # [ doc = " operation in parallel. Each of the returned partition tokens can be used" ] # [ doc = " by [StreamingRead][google.spanner.v1.Spanner.StreamingRead] to specify a subset of the read" ] # [ doc = " result to read. The same session and read-only transaction must be used by" ] # [ doc = " the PartitionReadRequest used to create the partition tokens and the" ] # [ doc = " ReadRequests that use the partition tokens. There are no ordering" ] # [ doc = " guarantees on rows returned among the returned partition tokens, or even" ] # [ doc = " within each individual StreamingRead call issued with a partition_token." ] # [ doc = "" ] # [ doc = " Partition tokens become invalid when the session used to create them" ] # [ doc = " is deleted, is idle for too long, begins a new transaction, or becomes too" ] # [ doc = " old. When any of these happen, it is not possible to resume the read, and" ] # [ doc = " the whole operation must be restarted from the beginning." ] pub async fn partition_read ( & mut self , request : impl tonic :: IntoRequest < super :: PartitionReadRequest > , ) -> Result < tonic :: Response < super :: PartitionResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.v1.Spanner/PartitionRead" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for SpannerClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for SpannerClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "SpannerClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/spanner/admin/database/v1.rs:732:20343 [INFO] [stdout] | [INFO] [stdout] 732 | # [ doc = r" Generated client implementations." ] pub mod database_admin_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud Spanner Database Admin API" ] # [ doc = "" ] # [ doc = " The Cloud Spanner Database Admin API can be used to create, drop, and" ] # [ doc = " list databases. It also enables updating the schema of pre-existing" ] # [ doc = " databases. It can be also used to create, delete and list backups for a" ] # [ doc = " database and to restore from an existing backup." ] pub struct DatabaseAdminClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > DatabaseAdminClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists Cloud Spanner databases." ] pub async fn list_databases ( & mut self , request : impl tonic :: IntoRequest < super :: ListDatabasesRequest > , ) -> Result < tonic :: Response < super :: ListDatabasesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/ListDatabases" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates a new Cloud Spanner database and starts to prepare it for serving." ] # [ doc = " The returned [long-running operation][google.longrunning.Operation] will" ] # [ doc = " have a name of the format `/operations/` and" ] # [ doc = " can be used to track preparation of the database. The" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type is" ] # [ doc = " [CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateDatabaseMetadata]. The" ] # [ doc = " [response][google.longrunning.Operation.response] field type is" ] # [ doc = " [Database][google.spanner.admin.database.v1.Database], if successful." ] pub async fn create_database ( & mut self , request : impl tonic :: IntoRequest < super :: CreateDatabaseRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/CreateDatabase" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the state of a Cloud Spanner database." ] pub async fn get_database ( & mut self , request : impl tonic :: IntoRequest < super :: GetDatabaseRequest > , ) -> Result < tonic :: Response < super :: Database > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/GetDatabase" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates the schema of a Cloud Spanner database by" ] # [ doc = " creating/altering/dropping tables, columns, indexes, etc. The returned" ] # [ doc = " [long-running operation][google.longrunning.Operation] will have a name of" ] # [ doc = " the format `/operations/` and can be used to" ] # [ doc = " track execution of the schema change(s). The" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type is" ] # [ doc = " [UpdateDatabaseDdlMetadata][google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata]. The operation has no response." ] pub async fn update_database_ddl ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateDatabaseDdlRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/UpdateDatabaseDdl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Drops (aka deletes) a Cloud Spanner database." ] # [ doc = " Completed backups for the database will be retained according to their" ] # [ doc = " `expire_time`." ] pub async fn drop_database ( & mut self , request : impl tonic :: IntoRequest < super :: DropDatabaseRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/DropDatabase" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns the schema of a Cloud Spanner database as a list of formatted" ] # [ doc = " DDL statements. This method does not show pending schema updates, those may" ] # [ doc = " be queried using the [Operations][google.longrunning.Operations] API." ] pub async fn get_database_ddl ( & mut self , request : impl tonic :: IntoRequest < super :: GetDatabaseDdlRequest > , ) -> Result < tonic :: Response < super :: GetDatabaseDdlResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/GetDatabaseDdl" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on a database or backup resource." ] # [ doc = " Replaces any existing policy." ] # [ doc = "" ] # [ doc = " Authorization requires `spanner.databases.setIamPolicy`" ] # [ doc = " permission on [resource][google.iam.v1.SetIamPolicyRequest.resource]." ] # [ doc = " For backups, authorization requires `spanner.backups.setIamPolicy`" ] # [ doc = " permission on [resource][google.iam.v1.SetIamPolicyRequest.resource]." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for a database or backup resource." ] # [ doc = " Returns an empty policy if a database or backup exists but does not have a" ] # [ doc = " policy set." ] # [ doc = "" ] # [ doc = " Authorization requires `spanner.databases.getIamPolicy` permission on" ] # [ doc = " [resource][google.iam.v1.GetIamPolicyRequest.resource]." ] # [ doc = " For backups, authorization requires `spanner.backups.getIamPolicy`" ] # [ doc = " permission on [resource][google.iam.v1.GetIamPolicyRequest.resource]." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that the caller has on the specified database or backup" ] # [ doc = " resource." ] # [ doc = "" ] # [ doc = " Attempting this RPC on a non-existent Cloud Spanner database will" ] # [ doc = " result in a NOT_FOUND error if the user has" ] # [ doc = " `spanner.databases.list` permission on the containing Cloud" ] # [ doc = " Spanner instance. Otherwise returns an empty set of permissions." ] # [ doc = " Calling this method on a backup that does not exist will" ] # [ doc = " result in a NOT_FOUND error if the user has" ] # [ doc = " `spanner.backups.list` permission on the containing instance." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Starts creating a new Cloud Spanner Backup." ] # [ doc = " The returned backup [long-running operation][google.longrunning.Operation]" ] # [ doc = " will have a name of the format" ] # [ doc = " `projects//instances//backups//operations/`" ] # [ doc = " and can be used to track creation of the backup. The" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type is" ] # [ doc = " [CreateBackupMetadata][google.spanner.admin.database.v1.CreateBackupMetadata]. The" ] # [ doc = " [response][google.longrunning.Operation.response] field type is" ] # [ doc = " [Backup][google.spanner.admin.database.v1.Backup], if successful. Cancelling the returned operation will stop the" ] # [ doc = " creation and delete the backup." ] # [ doc = " There can be only one pending backup creation per database. Backup creation" ] # [ doc = " of different databases can run concurrently." ] pub async fn create_backup ( & mut self , request : impl tonic :: IntoRequest < super :: CreateBackupRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/CreateBackup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets metadata on a pending or completed [Backup][google.spanner.admin.database.v1.Backup]." ] pub async fn get_backup ( & mut self , request : impl tonic :: IntoRequest < super :: GetBackupRequest > , ) -> Result < tonic :: Response < super :: Backup > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/GetBackup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates a pending or completed [Backup][google.spanner.admin.database.v1.Backup]." ] pub async fn update_backup ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateBackupRequest > , ) -> Result < tonic :: Response < super :: Backup > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/UpdateBackup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes a pending or completed [Backup][google.spanner.admin.database.v1.Backup]." ] pub async fn delete_backup ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteBackupRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/DeleteBackup" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists completed and pending backups." ] # [ doc = " Backups returned are ordered by `create_time` in descending order," ] # [ doc = " starting from the most recent `create_time`." ] pub async fn list_backups ( & mut self , request : impl tonic :: IntoRequest < super :: ListBackupsRequest > , ) -> Result < tonic :: Response < super :: ListBackupsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/ListBackups" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Create a new database by restoring from a completed backup. The new" ] # [ doc = " database must be in the same project and in an instance with the same" ] # [ doc = " instance configuration as the instance containing" ] # [ doc = " the backup. The returned database [long-running" ] # [ doc = " operation][google.longrunning.Operation] has a name of the format" ] # [ doc = " `projects//instances//databases//operations/`," ] # [ doc = " and can be used to track the progress of the operation, and to cancel it." ] # [ doc = " The [metadata][google.longrunning.Operation.metadata] field type is" ] # [ doc = " [RestoreDatabaseMetadata][google.spanner.admin.database.v1.RestoreDatabaseMetadata]." ] # [ doc = " The [response][google.longrunning.Operation.response] type" ] # [ doc = " is [Database][google.spanner.admin.database.v1.Database], if" ] # [ doc = " successful. Cancelling the returned operation will stop the restore and" ] # [ doc = " delete the database." ] # [ doc = " There can be only one database being restored into an instance at a time." ] # [ doc = " Once the restore operation completes, a new restore operation can be" ] # [ doc = " initiated, without waiting for the optimize operation associated with the" ] # [ doc = " first restore to complete." ] pub async fn restore_database ( & mut self , request : impl tonic :: IntoRequest < super :: RestoreDatabaseRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/RestoreDatabase" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists database [longrunning-operations][google.longrunning.Operation]." ] # [ doc = " A database operation has a name of the form" ] # [ doc = " `projects//instances//databases//operations/`." ] # [ doc = " The long-running operation" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type" ] # [ doc = " `metadata.type_url` describes the type of the metadata. Operations returned" ] # [ doc = " include those that have completed/failed/canceled within the last 7 days," ] # [ doc = " and pending operations." ] pub async fn list_database_operations ( & mut self , request : impl tonic :: IntoRequest < super :: ListDatabaseOperationsRequest > , ) -> Result < tonic :: Response < super :: ListDatabaseOperationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/ListDatabaseOperations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists the backup [long-running operations][google.longrunning.Operation] in" ] # [ doc = " the given instance. A backup operation has a name of the form" ] # [ doc = " `projects//instances//backups//operations/`." ] # [ doc = " The long-running operation" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type" ] # [ doc = " `metadata.type_url` describes the type of the metadata. Operations returned" ] # [ doc = " include those that have completed/failed/canceled within the last 7 days," ] # [ doc = " and pending operations. Operations returned are ordered by" ] # [ doc = " `operation.metadata.value.progress.start_time` in descending order starting" ] # [ doc = " from the most recently started operation." ] pub async fn list_backup_operations ( & mut self , request : impl tonic :: IntoRequest < super :: ListBackupOperationsRequest > , ) -> Result < tonic :: Response < super :: ListBackupOperationsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.database.v1.DatabaseAdmin/ListBackupOperations" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for DatabaseAdminClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for DatabaseAdminClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "DatabaseAdminClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `Deserialize`, `Serialize` [INFO] [stdout] --> src/google/spanner/admin/instance/v1.rs:326:15580 [INFO] [stdout] | [INFO] [stdout] 326 | # [ doc = r" Generated client implementations." ] pub mod instance_admin_client { # ! [ allow ( unused_variables , dead_code , missing_docs ) ] use tonic :: codegen :: * ; # [ doc = " Cloud Spanner Instance Admin API" ] # [ doc = "" ] # [ doc = " The Cloud Spanner Instance Admin API can be used to create, delete," ] # [ doc = " modify and list instances. Instances are dedicated Cloud Spanner serving" ] # [ doc = " and storage resources to be used by Cloud Spanner databases." ] # [ doc = "" ] # [ doc = " Each instance has a \"configuration\", which dictates where the" ] # [ doc = " serving resources for the Cloud Spanner instance are located (e.g.," ] # [ doc = " US-central, Europe). Configurations are created by Google based on" ] # [ doc = " resource availability." ] # [ doc = "" ] # [ doc = " Cloud Spanner billing is based on the instances that exist and their" ] # [ doc = " sizes. After an instance exists, there are no additional" ] # [ doc = " per-database or per-operation charges for use of the instance" ] # [ doc = " (though there may be additional network bandwidth charges)." ] # [ doc = " Instances offer isolation: problems with databases in one instance" ] # [ doc = " will not affect other instances. However, within an instance" ] # [ doc = " databases can affect each other. For example, if one database in an" ] # [ doc = " instance receives a lot of requests and consumes most of the" ] # [ doc = " instance resources, fewer resources are available for other" ] # [ doc = " databases in that instance, and their performance may suffer." ] pub struct InstanceAdminClient < T > { inner : tonic :: client :: Grpc < T > , } impl < T > InstanceAdminClient < T > where T : tonic :: client :: GrpcService < tonic :: body :: BoxBody > , T :: ResponseBody : Body + HttpBody + Send + 'static , T :: Error : Into < StdError > , < T :: ResponseBody as HttpBody > :: Error : Into < StdError > + Send , { pub fn new ( inner : T ) -> Self { let inner = tonic :: client :: Grpc :: new ( inner ) ; Self { inner } } pub fn with_interceptor ( inner : T , interceptor : impl Into < tonic :: Interceptor > ) -> Self { let inner = tonic :: client :: Grpc :: with_interceptor ( inner , interceptor ) ; Self { inner } } # [ doc = " Lists the supported instance configurations for a given project." ] pub async fn list_instance_configs ( & mut self , request : impl tonic :: IntoRequest < super :: ListInstanceConfigsRequest > , ) -> Result < tonic :: Response < super :: ListInstanceConfigsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/ListInstanceConfigs" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a particular instance configuration." ] pub async fn get_instance_config ( & mut self , request : impl tonic :: IntoRequest < super :: GetInstanceConfigRequest > , ) -> Result < tonic :: Response < super :: InstanceConfig > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/GetInstanceConfig" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Lists all instances in the given project." ] pub async fn list_instances ( & mut self , request : impl tonic :: IntoRequest < super :: ListInstancesRequest > , ) -> Result < tonic :: Response < super :: ListInstancesResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/ListInstances" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets information about a particular instance." ] pub async fn get_instance ( & mut self , request : impl tonic :: IntoRequest < super :: GetInstanceRequest > , ) -> Result < tonic :: Response < super :: Instance > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/GetInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Creates an instance and begins preparing it to begin serving. The" ] # [ doc = " returned [long-running operation][google.longrunning.Operation]" ] # [ doc = " can be used to track the progress of preparing the new" ] # [ doc = " instance. The instance name is assigned by the caller. If the" ] # [ doc = " named instance already exists, `CreateInstance` returns" ] # [ doc = " `ALREADY_EXISTS`." ] # [ doc = "" ] # [ doc = " Immediately upon completion of this request:" ] # [ doc = "" ] # [ doc = " * The instance is readable via the API, with all requested attributes" ] # [ doc = " but no allocated resources. Its state is `CREATING`." ] # [ doc = "" ] # [ doc = " Until completion of the returned operation:" ] # [ doc = "" ] # [ doc = " * Cancelling the operation renders the instance immediately unreadable" ] # [ doc = " via the API." ] # [ doc = " * The instance can be deleted." ] # [ doc = " * All other attempts to modify the instance are rejected." ] # [ doc = "" ] # [ doc = " Upon completion of the returned operation:" ] # [ doc = "" ] # [ doc = " * Billing for all successfully-allocated resources begins (some types" ] # [ doc = " may have lower than the requested levels)." ] # [ doc = " * Databases can be created in the instance." ] # [ doc = " * The instance's allocated resource levels are readable via the API." ] # [ doc = " * The instance's state becomes `READY`." ] # [ doc = "" ] # [ doc = " The returned [long-running operation][google.longrunning.Operation] will" ] # [ doc = " have a name of the format `/operations/` and" ] # [ doc = " can be used to track creation of the instance. The" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type is" ] # [ doc = " [CreateInstanceMetadata][google.spanner.admin.instance.v1.CreateInstanceMetadata]." ] # [ doc = " The [response][google.longrunning.Operation.response] field type is" ] # [ doc = " [Instance][google.spanner.admin.instance.v1.Instance], if successful." ] pub async fn create_instance ( & mut self , request : impl tonic :: IntoRequest < super :: CreateInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/CreateInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Updates an instance, and begins allocating or releasing resources" ] # [ doc = " as requested. The returned [long-running" ] # [ doc = " operation][google.longrunning.Operation] can be used to track the" ] # [ doc = " progress of updating the instance. If the named instance does not" ] # [ doc = " exist, returns `NOT_FOUND`." ] # [ doc = "" ] # [ doc = " Immediately upon completion of this request:" ] # [ doc = "" ] # [ doc = " * For resource types for which a decrease in the instance's allocation" ] # [ doc = " has been requested, billing is based on the newly-requested level." ] # [ doc = "" ] # [ doc = " Until completion of the returned operation:" ] # [ doc = "" ] # [ doc = " * Cancelling the operation sets its metadata's" ] # [ doc = " [cancel_time][google.spanner.admin.instance.v1.UpdateInstanceMetadata.cancel_time], and begins" ] # [ doc = " restoring resources to their pre-request values. The operation" ] # [ doc = " is guaranteed to succeed at undoing all resource changes," ] # [ doc = " after which point it terminates with a `CANCELLED` status." ] # [ doc = " * All other attempts to modify the instance are rejected." ] # [ doc = " * Reading the instance via the API continues to give the pre-request" ] # [ doc = " resource levels." ] # [ doc = "" ] # [ doc = " Upon completion of the returned operation:" ] # [ doc = "" ] # [ doc = " * Billing begins for all successfully-allocated resources (some types" ] # [ doc = " may have lower than the requested levels)." ] # [ doc = " * All newly-reserved resources are available for serving the instance's" ] # [ doc = " tables." ] # [ doc = " * The instance's new resource levels are readable via the API." ] # [ doc = "" ] # [ doc = " The returned [long-running operation][google.longrunning.Operation] will" ] # [ doc = " have a name of the format `/operations/` and" ] # [ doc = " can be used to track the instance modification. The" ] # [ doc = " [metadata][google.longrunning.Operation.metadata] field type is" ] # [ doc = " [UpdateInstanceMetadata][google.spanner.admin.instance.v1.UpdateInstanceMetadata]." ] # [ doc = " The [response][google.longrunning.Operation.response] field type is" ] # [ doc = " [Instance][google.spanner.admin.instance.v1.Instance], if successful." ] # [ doc = "" ] # [ doc = " Authorization requires `spanner.instances.update` permission on" ] # [ doc = " resource [name][google.spanner.admin.instance.v1.Instance.name]." ] pub async fn update_instance ( & mut self , request : impl tonic :: IntoRequest < super :: UpdateInstanceRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: longrunning :: Operation > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/UpdateInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Deletes an instance." ] # [ doc = "" ] # [ doc = " Immediately upon completion of the request:" ] # [ doc = "" ] # [ doc = " * Billing ceases for all of the instance's reserved resources." ] # [ doc = "" ] # [ doc = " Soon afterward:" ] # [ doc = "" ] # [ doc = " * The instance and *all of its databases* immediately and" ] # [ doc = " irrevocably disappear from the API. All data in the databases" ] # [ doc = " is permanently deleted." ] pub async fn delete_instance ( & mut self , request : impl tonic :: IntoRequest < super :: DeleteInstanceRequest > , ) -> Result < tonic :: Response < ( ) > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/DeleteInstance" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Sets the access control policy on an instance resource. Replaces any" ] # [ doc = " existing policy." ] # [ doc = "" ] # [ doc = " Authorization requires `spanner.instances.setIamPolicy` on" ] # [ doc = " [resource][google.iam.v1.SetIamPolicyRequest.resource]." ] pub async fn set_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: SetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/SetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Gets the access control policy for an instance resource. Returns an empty" ] # [ doc = " policy if an instance exists but does not have a policy set." ] # [ doc = "" ] # [ doc = " Authorization requires `spanner.instances.getIamPolicy` on" ] # [ doc = " [resource][google.iam.v1.GetIamPolicyRequest.resource]." ] pub async fn get_iam_policy ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: GetIamPolicyRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: Policy > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/GetIamPolicy" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } # [ doc = " Returns permissions that the caller has on the specified instance resource." ] # [ doc = "" ] # [ doc = " Attempting this RPC on a non-existent Cloud Spanner instance resource will" ] # [ doc = " result in a NOT_FOUND error if the user has `spanner.instances.list`" ] # [ doc = " permission on the containing Google Cloud Project. Otherwise returns an" ] # [ doc = " empty set of permissions." ] pub async fn test_iam_permissions ( & mut self , request : impl tonic :: IntoRequest < super :: super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsRequest > , ) -> Result < tonic :: Response < super :: super :: super :: super :: super :: iam :: v1 :: TestIamPermissionsResponse > , tonic :: Status > { self . inner . ready ( ) . await . map_err ( | e | { tonic :: Status :: new ( tonic :: Code :: Unknown , format ! ( "Service was not ready: {}" , e . into ( ) ) ) } ) ? ; let codec = tonic :: codec :: ProstCodec :: default ( ) ; let path = http :: uri :: PathAndQuery :: from_static ( "/google.spanner.admin.instance.v1.InstanceAdmin/TestIamPermissions" ) ; self . inner . unary ( request . into_request ( ) , path , codec ) . await } } impl < T : Clone > Clone for InstanceAdminClient < T > { fn clone ( & self ) -> Self { Self { inner : self . inner . clone ( ) , } } } impl < T > std :: fmt :: Debug for InstanceAdminClient < T > { fn fmt ( & self , f : & mut std :: fmt :: Formatter < '_ > ) -> std :: fmt :: Result { write ! ( f , "InstanceAdminClient {{ ... }}" ) } } }use serde :: { Serialize , Deserialize } ; [INFO] [stdout] | ^^^^^^^^^ ^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: build failed [INFO] running `Command { std: "docker" "inspect" "39b416500264b60a5641eac3ed298cdb6e07a20490f3b79d68b31f9600b3006d", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "39b416500264b60a5641eac3ed298cdb6e07a20490f3b79d68b31f9600b3006d", kill_on_drop: false }` [INFO] [stdout] 39b416500264b60a5641eac3ed298cdb6e07a20490f3b79d68b31f9600b3006d