google_cloud_vmwareengine_v1/
builder.rs

1// Copyright 2025 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14//
15// Code generated by sidekick. DO NOT EDIT.
16
17pub mod vmware_engine {
18    use crate::Result;
19
20    /// A builder for [VmwareEngine][crate::client::VmwareEngine].
21    ///
22    /// ```
23    /// # async fn sample() -> gax::client_builder::Result<()> {
24    /// # use google_cloud_vmwareengine_v1::*;
25    /// # use builder::vmware_engine::ClientBuilder;
26    /// # use client::VmwareEngine;
27    /// let builder : ClientBuilder = VmwareEngine::builder();
28    /// let client = builder
29    ///     .with_endpoint("https://vmwareengine.googleapis.com")
30    ///     .build().await?;
31    /// # Ok(()) }
32    /// ```
33    pub type ClientBuilder =
34        gax::client_builder::ClientBuilder<client::Factory, gaxi::options::Credentials>;
35
36    pub(crate) mod client {
37        use super::super::super::client::VmwareEngine;
38        pub struct Factory;
39        impl gax::client_builder::internal::ClientFactory for Factory {
40            type Client = VmwareEngine;
41            type Credentials = gaxi::options::Credentials;
42            async fn build(
43                self,
44                config: gaxi::options::ClientConfig,
45            ) -> gax::client_builder::Result<Self::Client> {
46                Self::Client::new(config).await
47            }
48        }
49    }
50
51    /// Common implementation for [crate::client::VmwareEngine] request builders.
52    #[derive(Clone, Debug)]
53    pub(crate) struct RequestBuilder<R: std::default::Default> {
54        stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
55        request: R,
56        options: gax::options::RequestOptions,
57    }
58
59    impl<R> RequestBuilder<R>
60    where
61        R: std::default::Default,
62    {
63        pub(crate) fn new(
64            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
65        ) -> Self {
66            Self {
67                stub,
68                request: R::default(),
69                options: gax::options::RequestOptions::default(),
70            }
71        }
72    }
73
74    /// The request builder for [VmwareEngine::list_private_clouds][crate::client::VmwareEngine::list_private_clouds] calls.
75    ///
76    /// # Example
77    /// ```
78    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListPrivateClouds;
79    /// # async fn sample() -> gax::Result<()> {
80    /// use gax::paginator::ItemPaginator;
81    ///
82    /// let builder = prepare_request_builder();
83    /// let mut items = builder.by_item();
84    /// while let Some(result) = items.next().await {
85    ///   let item = result?;
86    /// }
87    /// # Ok(()) }
88    ///
89    /// fn prepare_request_builder() -> ListPrivateClouds {
90    ///   # panic!();
91    ///   // ... details omitted ...
92    /// }
93    /// ```
94    #[derive(Clone, Debug)]
95    pub struct ListPrivateClouds(RequestBuilder<crate::model::ListPrivateCloudsRequest>);
96
97    impl ListPrivateClouds {
98        pub(crate) fn new(
99            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
100        ) -> Self {
101            Self(RequestBuilder::new(stub))
102        }
103
104        /// Sets the full request, replacing any prior values.
105        pub fn with_request<V: Into<crate::model::ListPrivateCloudsRequest>>(
106            mut self,
107            v: V,
108        ) -> Self {
109            self.0.request = v.into();
110            self
111        }
112
113        /// Sets all the options, replacing any prior values.
114        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
115            self.0.options = v.into();
116            self
117        }
118
119        /// Sends the request.
120        pub async fn send(self) -> Result<crate::model::ListPrivateCloudsResponse> {
121            (*self.0.stub)
122                .list_private_clouds(self.0.request, self.0.options)
123                .await
124                .map(gax::response::Response::into_body)
125        }
126
127        /// Streams each page in the collection.
128        pub fn by_page(
129            self,
130        ) -> impl gax::paginator::Paginator<crate::model::ListPrivateCloudsResponse, gax::error::Error>
131        {
132            use std::clone::Clone;
133            let token = self.0.request.page_token.clone();
134            let execute = move |token: String| {
135                let mut builder = self.clone();
136                builder.0.request = builder.0.request.set_page_token(token);
137                builder.send()
138            };
139            gax::paginator::internal::new_paginator(token, execute)
140        }
141
142        /// Streams each item in the collection.
143        pub fn by_item(
144            self,
145        ) -> impl gax::paginator::ItemPaginator<crate::model::ListPrivateCloudsResponse, gax::error::Error>
146        {
147            use gax::paginator::Paginator;
148            self.by_page().items()
149        }
150
151        /// Sets the value of [parent][crate::model::ListPrivateCloudsRequest::parent].
152        ///
153        /// This is a **required** field for requests.
154        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
155            self.0.request.parent = v.into();
156            self
157        }
158
159        /// Sets the value of [page_size][crate::model::ListPrivateCloudsRequest::page_size].
160        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
161            self.0.request.page_size = v.into();
162            self
163        }
164
165        /// Sets the value of [page_token][crate::model::ListPrivateCloudsRequest::page_token].
166        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
167            self.0.request.page_token = v.into();
168            self
169        }
170
171        /// Sets the value of [filter][crate::model::ListPrivateCloudsRequest::filter].
172        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
173            self.0.request.filter = v.into();
174            self
175        }
176
177        /// Sets the value of [order_by][crate::model::ListPrivateCloudsRequest::order_by].
178        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
179            self.0.request.order_by = v.into();
180            self
181        }
182    }
183
184    #[doc(hidden)]
185    impl gax::options::internal::RequestBuilder for ListPrivateClouds {
186        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
187            &mut self.0.options
188        }
189    }
190
191    /// The request builder for [VmwareEngine::get_private_cloud][crate::client::VmwareEngine::get_private_cloud] calls.
192    ///
193    /// # Example
194    /// ```
195    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetPrivateCloud;
196    /// # async fn sample() -> gax::Result<()> {
197    ///
198    /// let builder = prepare_request_builder();
199    /// let response = builder.send().await?;
200    /// # Ok(()) }
201    ///
202    /// fn prepare_request_builder() -> GetPrivateCloud {
203    ///   # panic!();
204    ///   // ... details omitted ...
205    /// }
206    /// ```
207    #[derive(Clone, Debug)]
208    pub struct GetPrivateCloud(RequestBuilder<crate::model::GetPrivateCloudRequest>);
209
210    impl GetPrivateCloud {
211        pub(crate) fn new(
212            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
213        ) -> Self {
214            Self(RequestBuilder::new(stub))
215        }
216
217        /// Sets the full request, replacing any prior values.
218        pub fn with_request<V: Into<crate::model::GetPrivateCloudRequest>>(mut self, v: V) -> Self {
219            self.0.request = v.into();
220            self
221        }
222
223        /// Sets all the options, replacing any prior values.
224        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
225            self.0.options = v.into();
226            self
227        }
228
229        /// Sends the request.
230        pub async fn send(self) -> Result<crate::model::PrivateCloud> {
231            (*self.0.stub)
232                .get_private_cloud(self.0.request, self.0.options)
233                .await
234                .map(gax::response::Response::into_body)
235        }
236
237        /// Sets the value of [name][crate::model::GetPrivateCloudRequest::name].
238        ///
239        /// This is a **required** field for requests.
240        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
241            self.0.request.name = v.into();
242            self
243        }
244    }
245
246    #[doc(hidden)]
247    impl gax::options::internal::RequestBuilder for GetPrivateCloud {
248        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
249            &mut self.0.options
250        }
251    }
252
253    /// The request builder for [VmwareEngine::create_private_cloud][crate::client::VmwareEngine::create_private_cloud] calls.
254    ///
255    /// # Example
256    /// ```
257    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreatePrivateCloud;
258    /// # async fn sample() -> gax::Result<()> {
259    /// use lro::Poller;
260    ///
261    /// let builder = prepare_request_builder();
262    /// let response = builder.poller().until_done().await?;
263    /// # Ok(()) }
264    ///
265    /// fn prepare_request_builder() -> CreatePrivateCloud {
266    ///   # panic!();
267    ///   // ... details omitted ...
268    /// }
269    /// ```
270    #[derive(Clone, Debug)]
271    pub struct CreatePrivateCloud(RequestBuilder<crate::model::CreatePrivateCloudRequest>);
272
273    impl CreatePrivateCloud {
274        pub(crate) fn new(
275            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
276        ) -> Self {
277            Self(RequestBuilder::new(stub))
278        }
279
280        /// Sets the full request, replacing any prior values.
281        pub fn with_request<V: Into<crate::model::CreatePrivateCloudRequest>>(
282            mut self,
283            v: V,
284        ) -> Self {
285            self.0.request = v.into();
286            self
287        }
288
289        /// Sets all the options, replacing any prior values.
290        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
291            self.0.options = v.into();
292            self
293        }
294
295        /// Sends the request.
296        ///
297        /// # Long running operations
298        ///
299        /// This starts, but does not poll, a longrunning operation. More information
300        /// on [create_private_cloud][crate::client::VmwareEngine::create_private_cloud].
301        pub async fn send(self) -> Result<longrunning::model::Operation> {
302            (*self.0.stub)
303                .create_private_cloud(self.0.request, self.0.options)
304                .await
305                .map(gax::response::Response::into_body)
306        }
307
308        /// Creates a [Poller][lro::Poller] to work with `create_private_cloud`.
309        pub fn poller(
310            self,
311        ) -> impl lro::Poller<crate::model::PrivateCloud, crate::model::OperationMetadata> {
312            type Operation = lro::internal::Operation<
313                crate::model::PrivateCloud,
314                crate::model::OperationMetadata,
315            >;
316            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
317            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
318
319            let stub = self.0.stub.clone();
320            let mut options = self.0.options.clone();
321            options.set_retry_policy(gax::retry_policy::NeverRetry);
322            let query = move |name| {
323                let stub = stub.clone();
324                let options = options.clone();
325                async {
326                    let op = GetOperation::new(stub)
327                        .set_name(name)
328                        .with_options(options)
329                        .send()
330                        .await?;
331                    Ok(Operation::new(op))
332                }
333            };
334
335            let start = move || async {
336                let op = self.send().await?;
337                Ok(Operation::new(op))
338            };
339
340            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
341        }
342
343        /// Sets the value of [parent][crate::model::CreatePrivateCloudRequest::parent].
344        ///
345        /// This is a **required** field for requests.
346        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
347            self.0.request.parent = v.into();
348            self
349        }
350
351        /// Sets the value of [private_cloud_id][crate::model::CreatePrivateCloudRequest::private_cloud_id].
352        ///
353        /// This is a **required** field for requests.
354        pub fn set_private_cloud_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
355            self.0.request.private_cloud_id = v.into();
356            self
357        }
358
359        /// Sets the value of [private_cloud][crate::model::CreatePrivateCloudRequest::private_cloud].
360        ///
361        /// This is a **required** field for requests.
362        pub fn set_private_cloud<T>(mut self, v: T) -> Self
363        where
364            T: std::convert::Into<crate::model::PrivateCloud>,
365        {
366            self.0.request.private_cloud = std::option::Option::Some(v.into());
367            self
368        }
369
370        /// Sets or clears the value of [private_cloud][crate::model::CreatePrivateCloudRequest::private_cloud].
371        ///
372        /// This is a **required** field for requests.
373        pub fn set_or_clear_private_cloud<T>(mut self, v: std::option::Option<T>) -> Self
374        where
375            T: std::convert::Into<crate::model::PrivateCloud>,
376        {
377            self.0.request.private_cloud = v.map(|x| x.into());
378            self
379        }
380
381        /// Sets the value of [request_id][crate::model::CreatePrivateCloudRequest::request_id].
382        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
383            self.0.request.request_id = v.into();
384            self
385        }
386
387        /// Sets the value of [validate_only][crate::model::CreatePrivateCloudRequest::validate_only].
388        pub fn set_validate_only<T: Into<bool>>(mut self, v: T) -> Self {
389            self.0.request.validate_only = v.into();
390            self
391        }
392    }
393
394    #[doc(hidden)]
395    impl gax::options::internal::RequestBuilder for CreatePrivateCloud {
396        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
397            &mut self.0.options
398        }
399    }
400
401    /// The request builder for [VmwareEngine::update_private_cloud][crate::client::VmwareEngine::update_private_cloud] calls.
402    ///
403    /// # Example
404    /// ```
405    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdatePrivateCloud;
406    /// # async fn sample() -> gax::Result<()> {
407    /// use lro::Poller;
408    ///
409    /// let builder = prepare_request_builder();
410    /// let response = builder.poller().until_done().await?;
411    /// # Ok(()) }
412    ///
413    /// fn prepare_request_builder() -> UpdatePrivateCloud {
414    ///   # panic!();
415    ///   // ... details omitted ...
416    /// }
417    /// ```
418    #[derive(Clone, Debug)]
419    pub struct UpdatePrivateCloud(RequestBuilder<crate::model::UpdatePrivateCloudRequest>);
420
421    impl UpdatePrivateCloud {
422        pub(crate) fn new(
423            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
424        ) -> Self {
425            Self(RequestBuilder::new(stub))
426        }
427
428        /// Sets the full request, replacing any prior values.
429        pub fn with_request<V: Into<crate::model::UpdatePrivateCloudRequest>>(
430            mut self,
431            v: V,
432        ) -> Self {
433            self.0.request = v.into();
434            self
435        }
436
437        /// Sets all the options, replacing any prior values.
438        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
439            self.0.options = v.into();
440            self
441        }
442
443        /// Sends the request.
444        ///
445        /// # Long running operations
446        ///
447        /// This starts, but does not poll, a longrunning operation. More information
448        /// on [update_private_cloud][crate::client::VmwareEngine::update_private_cloud].
449        pub async fn send(self) -> Result<longrunning::model::Operation> {
450            (*self.0.stub)
451                .update_private_cloud(self.0.request, self.0.options)
452                .await
453                .map(gax::response::Response::into_body)
454        }
455
456        /// Creates a [Poller][lro::Poller] to work with `update_private_cloud`.
457        pub fn poller(
458            self,
459        ) -> impl lro::Poller<crate::model::PrivateCloud, crate::model::OperationMetadata> {
460            type Operation = lro::internal::Operation<
461                crate::model::PrivateCloud,
462                crate::model::OperationMetadata,
463            >;
464            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
465            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
466
467            let stub = self.0.stub.clone();
468            let mut options = self.0.options.clone();
469            options.set_retry_policy(gax::retry_policy::NeverRetry);
470            let query = move |name| {
471                let stub = stub.clone();
472                let options = options.clone();
473                async {
474                    let op = GetOperation::new(stub)
475                        .set_name(name)
476                        .with_options(options)
477                        .send()
478                        .await?;
479                    Ok(Operation::new(op))
480                }
481            };
482
483            let start = move || async {
484                let op = self.send().await?;
485                Ok(Operation::new(op))
486            };
487
488            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
489        }
490
491        /// Sets the value of [private_cloud][crate::model::UpdatePrivateCloudRequest::private_cloud].
492        ///
493        /// This is a **required** field for requests.
494        pub fn set_private_cloud<T>(mut self, v: T) -> Self
495        where
496            T: std::convert::Into<crate::model::PrivateCloud>,
497        {
498            self.0.request.private_cloud = std::option::Option::Some(v.into());
499            self
500        }
501
502        /// Sets or clears the value of [private_cloud][crate::model::UpdatePrivateCloudRequest::private_cloud].
503        ///
504        /// This is a **required** field for requests.
505        pub fn set_or_clear_private_cloud<T>(mut self, v: std::option::Option<T>) -> Self
506        where
507            T: std::convert::Into<crate::model::PrivateCloud>,
508        {
509            self.0.request.private_cloud = v.map(|x| x.into());
510            self
511        }
512
513        /// Sets the value of [update_mask][crate::model::UpdatePrivateCloudRequest::update_mask].
514        ///
515        /// This is a **required** field for requests.
516        pub fn set_update_mask<T>(mut self, v: T) -> Self
517        where
518            T: std::convert::Into<wkt::FieldMask>,
519        {
520            self.0.request.update_mask = std::option::Option::Some(v.into());
521            self
522        }
523
524        /// Sets or clears the value of [update_mask][crate::model::UpdatePrivateCloudRequest::update_mask].
525        ///
526        /// This is a **required** field for requests.
527        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
528        where
529            T: std::convert::Into<wkt::FieldMask>,
530        {
531            self.0.request.update_mask = v.map(|x| x.into());
532            self
533        }
534
535        /// Sets the value of [request_id][crate::model::UpdatePrivateCloudRequest::request_id].
536        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
537            self.0.request.request_id = v.into();
538            self
539        }
540    }
541
542    #[doc(hidden)]
543    impl gax::options::internal::RequestBuilder for UpdatePrivateCloud {
544        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
545            &mut self.0.options
546        }
547    }
548
549    /// The request builder for [VmwareEngine::delete_private_cloud][crate::client::VmwareEngine::delete_private_cloud] calls.
550    ///
551    /// # Example
552    /// ```
553    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeletePrivateCloud;
554    /// # async fn sample() -> gax::Result<()> {
555    /// use lro::Poller;
556    ///
557    /// let builder = prepare_request_builder();
558    /// let response = builder.poller().until_done().await?;
559    /// # Ok(()) }
560    ///
561    /// fn prepare_request_builder() -> DeletePrivateCloud {
562    ///   # panic!();
563    ///   // ... details omitted ...
564    /// }
565    /// ```
566    #[derive(Clone, Debug)]
567    pub struct DeletePrivateCloud(RequestBuilder<crate::model::DeletePrivateCloudRequest>);
568
569    impl DeletePrivateCloud {
570        pub(crate) fn new(
571            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
572        ) -> Self {
573            Self(RequestBuilder::new(stub))
574        }
575
576        /// Sets the full request, replacing any prior values.
577        pub fn with_request<V: Into<crate::model::DeletePrivateCloudRequest>>(
578            mut self,
579            v: V,
580        ) -> Self {
581            self.0.request = v.into();
582            self
583        }
584
585        /// Sets all the options, replacing any prior values.
586        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
587            self.0.options = v.into();
588            self
589        }
590
591        /// Sends the request.
592        ///
593        /// # Long running operations
594        ///
595        /// This starts, but does not poll, a longrunning operation. More information
596        /// on [delete_private_cloud][crate::client::VmwareEngine::delete_private_cloud].
597        pub async fn send(self) -> Result<longrunning::model::Operation> {
598            (*self.0.stub)
599                .delete_private_cloud(self.0.request, self.0.options)
600                .await
601                .map(gax::response::Response::into_body)
602        }
603
604        /// Creates a [Poller][lro::Poller] to work with `delete_private_cloud`.
605        pub fn poller(
606            self,
607        ) -> impl lro::Poller<crate::model::PrivateCloud, crate::model::OperationMetadata> {
608            type Operation = lro::internal::Operation<
609                crate::model::PrivateCloud,
610                crate::model::OperationMetadata,
611            >;
612            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
613            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
614
615            let stub = self.0.stub.clone();
616            let mut options = self.0.options.clone();
617            options.set_retry_policy(gax::retry_policy::NeverRetry);
618            let query = move |name| {
619                let stub = stub.clone();
620                let options = options.clone();
621                async {
622                    let op = GetOperation::new(stub)
623                        .set_name(name)
624                        .with_options(options)
625                        .send()
626                        .await?;
627                    Ok(Operation::new(op))
628                }
629            };
630
631            let start = move || async {
632                let op = self.send().await?;
633                Ok(Operation::new(op))
634            };
635
636            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
637        }
638
639        /// Sets the value of [name][crate::model::DeletePrivateCloudRequest::name].
640        ///
641        /// This is a **required** field for requests.
642        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
643            self.0.request.name = v.into();
644            self
645        }
646
647        /// Sets the value of [request_id][crate::model::DeletePrivateCloudRequest::request_id].
648        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
649            self.0.request.request_id = v.into();
650            self
651        }
652
653        /// Sets the value of [force][crate::model::DeletePrivateCloudRequest::force].
654        pub fn set_force<T: Into<bool>>(mut self, v: T) -> Self {
655            self.0.request.force = v.into();
656            self
657        }
658
659        /// Sets the value of [delay_hours][crate::model::DeletePrivateCloudRequest::delay_hours].
660        pub fn set_delay_hours<T>(mut self, v: T) -> Self
661        where
662            T: std::convert::Into<i32>,
663        {
664            self.0.request.delay_hours = std::option::Option::Some(v.into());
665            self
666        }
667
668        /// Sets or clears the value of [delay_hours][crate::model::DeletePrivateCloudRequest::delay_hours].
669        pub fn set_or_clear_delay_hours<T>(mut self, v: std::option::Option<T>) -> Self
670        where
671            T: std::convert::Into<i32>,
672        {
673            self.0.request.delay_hours = v.map(|x| x.into());
674            self
675        }
676    }
677
678    #[doc(hidden)]
679    impl gax::options::internal::RequestBuilder for DeletePrivateCloud {
680        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
681            &mut self.0.options
682        }
683    }
684
685    /// The request builder for [VmwareEngine::undelete_private_cloud][crate::client::VmwareEngine::undelete_private_cloud] calls.
686    ///
687    /// # Example
688    /// ```
689    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UndeletePrivateCloud;
690    /// # async fn sample() -> gax::Result<()> {
691    /// use lro::Poller;
692    ///
693    /// let builder = prepare_request_builder();
694    /// let response = builder.poller().until_done().await?;
695    /// # Ok(()) }
696    ///
697    /// fn prepare_request_builder() -> UndeletePrivateCloud {
698    ///   # panic!();
699    ///   // ... details omitted ...
700    /// }
701    /// ```
702    #[derive(Clone, Debug)]
703    pub struct UndeletePrivateCloud(RequestBuilder<crate::model::UndeletePrivateCloudRequest>);
704
705    impl UndeletePrivateCloud {
706        pub(crate) fn new(
707            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
708        ) -> Self {
709            Self(RequestBuilder::new(stub))
710        }
711
712        /// Sets the full request, replacing any prior values.
713        pub fn with_request<V: Into<crate::model::UndeletePrivateCloudRequest>>(
714            mut self,
715            v: V,
716        ) -> Self {
717            self.0.request = v.into();
718            self
719        }
720
721        /// Sets all the options, replacing any prior values.
722        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
723            self.0.options = v.into();
724            self
725        }
726
727        /// Sends the request.
728        ///
729        /// # Long running operations
730        ///
731        /// This starts, but does not poll, a longrunning operation. More information
732        /// on [undelete_private_cloud][crate::client::VmwareEngine::undelete_private_cloud].
733        pub async fn send(self) -> Result<longrunning::model::Operation> {
734            (*self.0.stub)
735                .undelete_private_cloud(self.0.request, self.0.options)
736                .await
737                .map(gax::response::Response::into_body)
738        }
739
740        /// Creates a [Poller][lro::Poller] to work with `undelete_private_cloud`.
741        pub fn poller(
742            self,
743        ) -> impl lro::Poller<crate::model::PrivateCloud, crate::model::OperationMetadata> {
744            type Operation = lro::internal::Operation<
745                crate::model::PrivateCloud,
746                crate::model::OperationMetadata,
747            >;
748            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
749            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
750
751            let stub = self.0.stub.clone();
752            let mut options = self.0.options.clone();
753            options.set_retry_policy(gax::retry_policy::NeverRetry);
754            let query = move |name| {
755                let stub = stub.clone();
756                let options = options.clone();
757                async {
758                    let op = GetOperation::new(stub)
759                        .set_name(name)
760                        .with_options(options)
761                        .send()
762                        .await?;
763                    Ok(Operation::new(op))
764                }
765            };
766
767            let start = move || async {
768                let op = self.send().await?;
769                Ok(Operation::new(op))
770            };
771
772            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
773        }
774
775        /// Sets the value of [name][crate::model::UndeletePrivateCloudRequest::name].
776        ///
777        /// This is a **required** field for requests.
778        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
779            self.0.request.name = v.into();
780            self
781        }
782
783        /// Sets the value of [request_id][crate::model::UndeletePrivateCloudRequest::request_id].
784        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
785            self.0.request.request_id = v.into();
786            self
787        }
788    }
789
790    #[doc(hidden)]
791    impl gax::options::internal::RequestBuilder for UndeletePrivateCloud {
792        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
793            &mut self.0.options
794        }
795    }
796
797    /// The request builder for [VmwareEngine::list_clusters][crate::client::VmwareEngine::list_clusters] calls.
798    ///
799    /// # Example
800    /// ```
801    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListClusters;
802    /// # async fn sample() -> gax::Result<()> {
803    /// use gax::paginator::ItemPaginator;
804    ///
805    /// let builder = prepare_request_builder();
806    /// let mut items = builder.by_item();
807    /// while let Some(result) = items.next().await {
808    ///   let item = result?;
809    /// }
810    /// # Ok(()) }
811    ///
812    /// fn prepare_request_builder() -> ListClusters {
813    ///   # panic!();
814    ///   // ... details omitted ...
815    /// }
816    /// ```
817    #[derive(Clone, Debug)]
818    pub struct ListClusters(RequestBuilder<crate::model::ListClustersRequest>);
819
820    impl ListClusters {
821        pub(crate) fn new(
822            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
823        ) -> Self {
824            Self(RequestBuilder::new(stub))
825        }
826
827        /// Sets the full request, replacing any prior values.
828        pub fn with_request<V: Into<crate::model::ListClustersRequest>>(mut self, v: V) -> Self {
829            self.0.request = v.into();
830            self
831        }
832
833        /// Sets all the options, replacing any prior values.
834        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
835            self.0.options = v.into();
836            self
837        }
838
839        /// Sends the request.
840        pub async fn send(self) -> Result<crate::model::ListClustersResponse> {
841            (*self.0.stub)
842                .list_clusters(self.0.request, self.0.options)
843                .await
844                .map(gax::response::Response::into_body)
845        }
846
847        /// Streams each page in the collection.
848        pub fn by_page(
849            self,
850        ) -> impl gax::paginator::Paginator<crate::model::ListClustersResponse, gax::error::Error>
851        {
852            use std::clone::Clone;
853            let token = self.0.request.page_token.clone();
854            let execute = move |token: String| {
855                let mut builder = self.clone();
856                builder.0.request = builder.0.request.set_page_token(token);
857                builder.send()
858            };
859            gax::paginator::internal::new_paginator(token, execute)
860        }
861
862        /// Streams each item in the collection.
863        pub fn by_item(
864            self,
865        ) -> impl gax::paginator::ItemPaginator<crate::model::ListClustersResponse, gax::error::Error>
866        {
867            use gax::paginator::Paginator;
868            self.by_page().items()
869        }
870
871        /// Sets the value of [parent][crate::model::ListClustersRequest::parent].
872        ///
873        /// This is a **required** field for requests.
874        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
875            self.0.request.parent = v.into();
876            self
877        }
878
879        /// Sets the value of [page_size][crate::model::ListClustersRequest::page_size].
880        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
881            self.0.request.page_size = v.into();
882            self
883        }
884
885        /// Sets the value of [page_token][crate::model::ListClustersRequest::page_token].
886        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
887            self.0.request.page_token = v.into();
888            self
889        }
890
891        /// Sets the value of [filter][crate::model::ListClustersRequest::filter].
892        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
893            self.0.request.filter = v.into();
894            self
895        }
896
897        /// Sets the value of [order_by][crate::model::ListClustersRequest::order_by].
898        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
899            self.0.request.order_by = v.into();
900            self
901        }
902    }
903
904    #[doc(hidden)]
905    impl gax::options::internal::RequestBuilder for ListClusters {
906        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
907            &mut self.0.options
908        }
909    }
910
911    /// The request builder for [VmwareEngine::get_cluster][crate::client::VmwareEngine::get_cluster] calls.
912    ///
913    /// # Example
914    /// ```
915    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetCluster;
916    /// # async fn sample() -> gax::Result<()> {
917    ///
918    /// let builder = prepare_request_builder();
919    /// let response = builder.send().await?;
920    /// # Ok(()) }
921    ///
922    /// fn prepare_request_builder() -> GetCluster {
923    ///   # panic!();
924    ///   // ... details omitted ...
925    /// }
926    /// ```
927    #[derive(Clone, Debug)]
928    pub struct GetCluster(RequestBuilder<crate::model::GetClusterRequest>);
929
930    impl GetCluster {
931        pub(crate) fn new(
932            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
933        ) -> Self {
934            Self(RequestBuilder::new(stub))
935        }
936
937        /// Sets the full request, replacing any prior values.
938        pub fn with_request<V: Into<crate::model::GetClusterRequest>>(mut self, v: V) -> Self {
939            self.0.request = v.into();
940            self
941        }
942
943        /// Sets all the options, replacing any prior values.
944        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
945            self.0.options = v.into();
946            self
947        }
948
949        /// Sends the request.
950        pub async fn send(self) -> Result<crate::model::Cluster> {
951            (*self.0.stub)
952                .get_cluster(self.0.request, self.0.options)
953                .await
954                .map(gax::response::Response::into_body)
955        }
956
957        /// Sets the value of [name][crate::model::GetClusterRequest::name].
958        ///
959        /// This is a **required** field for requests.
960        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
961            self.0.request.name = v.into();
962            self
963        }
964    }
965
966    #[doc(hidden)]
967    impl gax::options::internal::RequestBuilder for GetCluster {
968        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
969            &mut self.0.options
970        }
971    }
972
973    /// The request builder for [VmwareEngine::create_cluster][crate::client::VmwareEngine::create_cluster] calls.
974    ///
975    /// # Example
976    /// ```
977    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateCluster;
978    /// # async fn sample() -> gax::Result<()> {
979    /// use lro::Poller;
980    ///
981    /// let builder = prepare_request_builder();
982    /// let response = builder.poller().until_done().await?;
983    /// # Ok(()) }
984    ///
985    /// fn prepare_request_builder() -> CreateCluster {
986    ///   # panic!();
987    ///   // ... details omitted ...
988    /// }
989    /// ```
990    #[derive(Clone, Debug)]
991    pub struct CreateCluster(RequestBuilder<crate::model::CreateClusterRequest>);
992
993    impl CreateCluster {
994        pub(crate) fn new(
995            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
996        ) -> Self {
997            Self(RequestBuilder::new(stub))
998        }
999
1000        /// Sets the full request, replacing any prior values.
1001        pub fn with_request<V: Into<crate::model::CreateClusterRequest>>(mut self, v: V) -> Self {
1002            self.0.request = v.into();
1003            self
1004        }
1005
1006        /// Sets all the options, replacing any prior values.
1007        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1008            self.0.options = v.into();
1009            self
1010        }
1011
1012        /// Sends the request.
1013        ///
1014        /// # Long running operations
1015        ///
1016        /// This starts, but does not poll, a longrunning operation. More information
1017        /// on [create_cluster][crate::client::VmwareEngine::create_cluster].
1018        pub async fn send(self) -> Result<longrunning::model::Operation> {
1019            (*self.0.stub)
1020                .create_cluster(self.0.request, self.0.options)
1021                .await
1022                .map(gax::response::Response::into_body)
1023        }
1024
1025        /// Creates a [Poller][lro::Poller] to work with `create_cluster`.
1026        pub fn poller(
1027            self,
1028        ) -> impl lro::Poller<crate::model::Cluster, crate::model::OperationMetadata> {
1029            type Operation =
1030                lro::internal::Operation<crate::model::Cluster, crate::model::OperationMetadata>;
1031            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
1032            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
1033
1034            let stub = self.0.stub.clone();
1035            let mut options = self.0.options.clone();
1036            options.set_retry_policy(gax::retry_policy::NeverRetry);
1037            let query = move |name| {
1038                let stub = stub.clone();
1039                let options = options.clone();
1040                async {
1041                    let op = GetOperation::new(stub)
1042                        .set_name(name)
1043                        .with_options(options)
1044                        .send()
1045                        .await?;
1046                    Ok(Operation::new(op))
1047                }
1048            };
1049
1050            let start = move || async {
1051                let op = self.send().await?;
1052                Ok(Operation::new(op))
1053            };
1054
1055            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
1056        }
1057
1058        /// Sets the value of [parent][crate::model::CreateClusterRequest::parent].
1059        ///
1060        /// This is a **required** field for requests.
1061        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
1062            self.0.request.parent = v.into();
1063            self
1064        }
1065
1066        /// Sets the value of [cluster_id][crate::model::CreateClusterRequest::cluster_id].
1067        ///
1068        /// This is a **required** field for requests.
1069        pub fn set_cluster_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
1070            self.0.request.cluster_id = v.into();
1071            self
1072        }
1073
1074        /// Sets the value of [cluster][crate::model::CreateClusterRequest::cluster].
1075        ///
1076        /// This is a **required** field for requests.
1077        pub fn set_cluster<T>(mut self, v: T) -> Self
1078        where
1079            T: std::convert::Into<crate::model::Cluster>,
1080        {
1081            self.0.request.cluster = std::option::Option::Some(v.into());
1082            self
1083        }
1084
1085        /// Sets or clears the value of [cluster][crate::model::CreateClusterRequest::cluster].
1086        ///
1087        /// This is a **required** field for requests.
1088        pub fn set_or_clear_cluster<T>(mut self, v: std::option::Option<T>) -> Self
1089        where
1090            T: std::convert::Into<crate::model::Cluster>,
1091        {
1092            self.0.request.cluster = v.map(|x| x.into());
1093            self
1094        }
1095
1096        /// Sets the value of [request_id][crate::model::CreateClusterRequest::request_id].
1097        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
1098            self.0.request.request_id = v.into();
1099            self
1100        }
1101
1102        /// Sets the value of [validate_only][crate::model::CreateClusterRequest::validate_only].
1103        pub fn set_validate_only<T: Into<bool>>(mut self, v: T) -> Self {
1104            self.0.request.validate_only = v.into();
1105            self
1106        }
1107    }
1108
1109    #[doc(hidden)]
1110    impl gax::options::internal::RequestBuilder for CreateCluster {
1111        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1112            &mut self.0.options
1113        }
1114    }
1115
1116    /// The request builder for [VmwareEngine::update_cluster][crate::client::VmwareEngine::update_cluster] calls.
1117    ///
1118    /// # Example
1119    /// ```
1120    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateCluster;
1121    /// # async fn sample() -> gax::Result<()> {
1122    /// use lro::Poller;
1123    ///
1124    /// let builder = prepare_request_builder();
1125    /// let response = builder.poller().until_done().await?;
1126    /// # Ok(()) }
1127    ///
1128    /// fn prepare_request_builder() -> UpdateCluster {
1129    ///   # panic!();
1130    ///   // ... details omitted ...
1131    /// }
1132    /// ```
1133    #[derive(Clone, Debug)]
1134    pub struct UpdateCluster(RequestBuilder<crate::model::UpdateClusterRequest>);
1135
1136    impl UpdateCluster {
1137        pub(crate) fn new(
1138            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
1139        ) -> Self {
1140            Self(RequestBuilder::new(stub))
1141        }
1142
1143        /// Sets the full request, replacing any prior values.
1144        pub fn with_request<V: Into<crate::model::UpdateClusterRequest>>(mut self, v: V) -> Self {
1145            self.0.request = v.into();
1146            self
1147        }
1148
1149        /// Sets all the options, replacing any prior values.
1150        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1151            self.0.options = v.into();
1152            self
1153        }
1154
1155        /// Sends the request.
1156        ///
1157        /// # Long running operations
1158        ///
1159        /// This starts, but does not poll, a longrunning operation. More information
1160        /// on [update_cluster][crate::client::VmwareEngine::update_cluster].
1161        pub async fn send(self) -> Result<longrunning::model::Operation> {
1162            (*self.0.stub)
1163                .update_cluster(self.0.request, self.0.options)
1164                .await
1165                .map(gax::response::Response::into_body)
1166        }
1167
1168        /// Creates a [Poller][lro::Poller] to work with `update_cluster`.
1169        pub fn poller(
1170            self,
1171        ) -> impl lro::Poller<crate::model::Cluster, crate::model::OperationMetadata> {
1172            type Operation =
1173                lro::internal::Operation<crate::model::Cluster, crate::model::OperationMetadata>;
1174            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
1175            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
1176
1177            let stub = self.0.stub.clone();
1178            let mut options = self.0.options.clone();
1179            options.set_retry_policy(gax::retry_policy::NeverRetry);
1180            let query = move |name| {
1181                let stub = stub.clone();
1182                let options = options.clone();
1183                async {
1184                    let op = GetOperation::new(stub)
1185                        .set_name(name)
1186                        .with_options(options)
1187                        .send()
1188                        .await?;
1189                    Ok(Operation::new(op))
1190                }
1191            };
1192
1193            let start = move || async {
1194                let op = self.send().await?;
1195                Ok(Operation::new(op))
1196            };
1197
1198            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
1199        }
1200
1201        /// Sets the value of [update_mask][crate::model::UpdateClusterRequest::update_mask].
1202        ///
1203        /// This is a **required** field for requests.
1204        pub fn set_update_mask<T>(mut self, v: T) -> Self
1205        where
1206            T: std::convert::Into<wkt::FieldMask>,
1207        {
1208            self.0.request.update_mask = std::option::Option::Some(v.into());
1209            self
1210        }
1211
1212        /// Sets or clears the value of [update_mask][crate::model::UpdateClusterRequest::update_mask].
1213        ///
1214        /// This is a **required** field for requests.
1215        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
1216        where
1217            T: std::convert::Into<wkt::FieldMask>,
1218        {
1219            self.0.request.update_mask = v.map(|x| x.into());
1220            self
1221        }
1222
1223        /// Sets the value of [cluster][crate::model::UpdateClusterRequest::cluster].
1224        ///
1225        /// This is a **required** field for requests.
1226        pub fn set_cluster<T>(mut self, v: T) -> Self
1227        where
1228            T: std::convert::Into<crate::model::Cluster>,
1229        {
1230            self.0.request.cluster = std::option::Option::Some(v.into());
1231            self
1232        }
1233
1234        /// Sets or clears the value of [cluster][crate::model::UpdateClusterRequest::cluster].
1235        ///
1236        /// This is a **required** field for requests.
1237        pub fn set_or_clear_cluster<T>(mut self, v: std::option::Option<T>) -> Self
1238        where
1239            T: std::convert::Into<crate::model::Cluster>,
1240        {
1241            self.0.request.cluster = v.map(|x| x.into());
1242            self
1243        }
1244
1245        /// Sets the value of [request_id][crate::model::UpdateClusterRequest::request_id].
1246        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
1247            self.0.request.request_id = v.into();
1248            self
1249        }
1250
1251        /// Sets the value of [validate_only][crate::model::UpdateClusterRequest::validate_only].
1252        pub fn set_validate_only<T: Into<bool>>(mut self, v: T) -> Self {
1253            self.0.request.validate_only = v.into();
1254            self
1255        }
1256    }
1257
1258    #[doc(hidden)]
1259    impl gax::options::internal::RequestBuilder for UpdateCluster {
1260        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1261            &mut self.0.options
1262        }
1263    }
1264
1265    /// The request builder for [VmwareEngine::delete_cluster][crate::client::VmwareEngine::delete_cluster] calls.
1266    ///
1267    /// # Example
1268    /// ```
1269    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteCluster;
1270    /// # async fn sample() -> gax::Result<()> {
1271    /// use lro::Poller;
1272    ///
1273    /// let builder = prepare_request_builder();
1274    /// let response = builder.poller().until_done().await?;
1275    /// # Ok(()) }
1276    ///
1277    /// fn prepare_request_builder() -> DeleteCluster {
1278    ///   # panic!();
1279    ///   // ... details omitted ...
1280    /// }
1281    /// ```
1282    #[derive(Clone, Debug)]
1283    pub struct DeleteCluster(RequestBuilder<crate::model::DeleteClusterRequest>);
1284
1285    impl DeleteCluster {
1286        pub(crate) fn new(
1287            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
1288        ) -> Self {
1289            Self(RequestBuilder::new(stub))
1290        }
1291
1292        /// Sets the full request, replacing any prior values.
1293        pub fn with_request<V: Into<crate::model::DeleteClusterRequest>>(mut self, v: V) -> Self {
1294            self.0.request = v.into();
1295            self
1296        }
1297
1298        /// Sets all the options, replacing any prior values.
1299        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1300            self.0.options = v.into();
1301            self
1302        }
1303
1304        /// Sends the request.
1305        ///
1306        /// # Long running operations
1307        ///
1308        /// This starts, but does not poll, a longrunning operation. More information
1309        /// on [delete_cluster][crate::client::VmwareEngine::delete_cluster].
1310        pub async fn send(self) -> Result<longrunning::model::Operation> {
1311            (*self.0.stub)
1312                .delete_cluster(self.0.request, self.0.options)
1313                .await
1314                .map(gax::response::Response::into_body)
1315        }
1316
1317        /// Creates a [Poller][lro::Poller] to work with `delete_cluster`.
1318        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
1319            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
1320            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
1321            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
1322
1323            let stub = self.0.stub.clone();
1324            let mut options = self.0.options.clone();
1325            options.set_retry_policy(gax::retry_policy::NeverRetry);
1326            let query = move |name| {
1327                let stub = stub.clone();
1328                let options = options.clone();
1329                async {
1330                    let op = GetOperation::new(stub)
1331                        .set_name(name)
1332                        .with_options(options)
1333                        .send()
1334                        .await?;
1335                    Ok(Operation::new(op))
1336                }
1337            };
1338
1339            let start = move || async {
1340                let op = self.send().await?;
1341                Ok(Operation::new(op))
1342            };
1343
1344            lro::internal::new_unit_response_poller(
1345                polling_error_policy,
1346                polling_backoff_policy,
1347                start,
1348                query,
1349            )
1350        }
1351
1352        /// Sets the value of [name][crate::model::DeleteClusterRequest::name].
1353        ///
1354        /// This is a **required** field for requests.
1355        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
1356            self.0.request.name = v.into();
1357            self
1358        }
1359
1360        /// Sets the value of [request_id][crate::model::DeleteClusterRequest::request_id].
1361        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
1362            self.0.request.request_id = v.into();
1363            self
1364        }
1365    }
1366
1367    #[doc(hidden)]
1368    impl gax::options::internal::RequestBuilder for DeleteCluster {
1369        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1370            &mut self.0.options
1371        }
1372    }
1373
1374    /// The request builder for [VmwareEngine::list_nodes][crate::client::VmwareEngine::list_nodes] calls.
1375    ///
1376    /// # Example
1377    /// ```
1378    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListNodes;
1379    /// # async fn sample() -> gax::Result<()> {
1380    /// use gax::paginator::ItemPaginator;
1381    ///
1382    /// let builder = prepare_request_builder();
1383    /// let mut items = builder.by_item();
1384    /// while let Some(result) = items.next().await {
1385    ///   let item = result?;
1386    /// }
1387    /// # Ok(()) }
1388    ///
1389    /// fn prepare_request_builder() -> ListNodes {
1390    ///   # panic!();
1391    ///   // ... details omitted ...
1392    /// }
1393    /// ```
1394    #[derive(Clone, Debug)]
1395    pub struct ListNodes(RequestBuilder<crate::model::ListNodesRequest>);
1396
1397    impl ListNodes {
1398        pub(crate) fn new(
1399            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
1400        ) -> Self {
1401            Self(RequestBuilder::new(stub))
1402        }
1403
1404        /// Sets the full request, replacing any prior values.
1405        pub fn with_request<V: Into<crate::model::ListNodesRequest>>(mut self, v: V) -> Self {
1406            self.0.request = v.into();
1407            self
1408        }
1409
1410        /// Sets all the options, replacing any prior values.
1411        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1412            self.0.options = v.into();
1413            self
1414        }
1415
1416        /// Sends the request.
1417        pub async fn send(self) -> Result<crate::model::ListNodesResponse> {
1418            (*self.0.stub)
1419                .list_nodes(self.0.request, self.0.options)
1420                .await
1421                .map(gax::response::Response::into_body)
1422        }
1423
1424        /// Streams each page in the collection.
1425        pub fn by_page(
1426            self,
1427        ) -> impl gax::paginator::Paginator<crate::model::ListNodesResponse, gax::error::Error>
1428        {
1429            use std::clone::Clone;
1430            let token = self.0.request.page_token.clone();
1431            let execute = move |token: String| {
1432                let mut builder = self.clone();
1433                builder.0.request = builder.0.request.set_page_token(token);
1434                builder.send()
1435            };
1436            gax::paginator::internal::new_paginator(token, execute)
1437        }
1438
1439        /// Streams each item in the collection.
1440        pub fn by_item(
1441            self,
1442        ) -> impl gax::paginator::ItemPaginator<crate::model::ListNodesResponse, gax::error::Error>
1443        {
1444            use gax::paginator::Paginator;
1445            self.by_page().items()
1446        }
1447
1448        /// Sets the value of [parent][crate::model::ListNodesRequest::parent].
1449        ///
1450        /// This is a **required** field for requests.
1451        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
1452            self.0.request.parent = v.into();
1453            self
1454        }
1455
1456        /// Sets the value of [page_size][crate::model::ListNodesRequest::page_size].
1457        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
1458            self.0.request.page_size = v.into();
1459            self
1460        }
1461
1462        /// Sets the value of [page_token][crate::model::ListNodesRequest::page_token].
1463        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
1464            self.0.request.page_token = v.into();
1465            self
1466        }
1467    }
1468
1469    #[doc(hidden)]
1470    impl gax::options::internal::RequestBuilder for ListNodes {
1471        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1472            &mut self.0.options
1473        }
1474    }
1475
1476    /// The request builder for [VmwareEngine::get_node][crate::client::VmwareEngine::get_node] calls.
1477    ///
1478    /// # Example
1479    /// ```
1480    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetNode;
1481    /// # async fn sample() -> gax::Result<()> {
1482    ///
1483    /// let builder = prepare_request_builder();
1484    /// let response = builder.send().await?;
1485    /// # Ok(()) }
1486    ///
1487    /// fn prepare_request_builder() -> GetNode {
1488    ///   # panic!();
1489    ///   // ... details omitted ...
1490    /// }
1491    /// ```
1492    #[derive(Clone, Debug)]
1493    pub struct GetNode(RequestBuilder<crate::model::GetNodeRequest>);
1494
1495    impl GetNode {
1496        pub(crate) fn new(
1497            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
1498        ) -> Self {
1499            Self(RequestBuilder::new(stub))
1500        }
1501
1502        /// Sets the full request, replacing any prior values.
1503        pub fn with_request<V: Into<crate::model::GetNodeRequest>>(mut self, v: V) -> Self {
1504            self.0.request = v.into();
1505            self
1506        }
1507
1508        /// Sets all the options, replacing any prior values.
1509        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1510            self.0.options = v.into();
1511            self
1512        }
1513
1514        /// Sends the request.
1515        pub async fn send(self) -> Result<crate::model::Node> {
1516            (*self.0.stub)
1517                .get_node(self.0.request, self.0.options)
1518                .await
1519                .map(gax::response::Response::into_body)
1520        }
1521
1522        /// Sets the value of [name][crate::model::GetNodeRequest::name].
1523        ///
1524        /// This is a **required** field for requests.
1525        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
1526            self.0.request.name = v.into();
1527            self
1528        }
1529    }
1530
1531    #[doc(hidden)]
1532    impl gax::options::internal::RequestBuilder for GetNode {
1533        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1534            &mut self.0.options
1535        }
1536    }
1537
1538    /// The request builder for [VmwareEngine::list_external_addresses][crate::client::VmwareEngine::list_external_addresses] calls.
1539    ///
1540    /// # Example
1541    /// ```
1542    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListExternalAddresses;
1543    /// # async fn sample() -> gax::Result<()> {
1544    /// use gax::paginator::ItemPaginator;
1545    ///
1546    /// let builder = prepare_request_builder();
1547    /// let mut items = builder.by_item();
1548    /// while let Some(result) = items.next().await {
1549    ///   let item = result?;
1550    /// }
1551    /// # Ok(()) }
1552    ///
1553    /// fn prepare_request_builder() -> ListExternalAddresses {
1554    ///   # panic!();
1555    ///   // ... details omitted ...
1556    /// }
1557    /// ```
1558    #[derive(Clone, Debug)]
1559    pub struct ListExternalAddresses(RequestBuilder<crate::model::ListExternalAddressesRequest>);
1560
1561    impl ListExternalAddresses {
1562        pub(crate) fn new(
1563            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
1564        ) -> Self {
1565            Self(RequestBuilder::new(stub))
1566        }
1567
1568        /// Sets the full request, replacing any prior values.
1569        pub fn with_request<V: Into<crate::model::ListExternalAddressesRequest>>(
1570            mut self,
1571            v: V,
1572        ) -> Self {
1573            self.0.request = v.into();
1574            self
1575        }
1576
1577        /// Sets all the options, replacing any prior values.
1578        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1579            self.0.options = v.into();
1580            self
1581        }
1582
1583        /// Sends the request.
1584        pub async fn send(self) -> Result<crate::model::ListExternalAddressesResponse> {
1585            (*self.0.stub)
1586                .list_external_addresses(self.0.request, self.0.options)
1587                .await
1588                .map(gax::response::Response::into_body)
1589        }
1590
1591        /// Streams each page in the collection.
1592        pub fn by_page(
1593            self,
1594        ) -> impl gax::paginator::Paginator<crate::model::ListExternalAddressesResponse, gax::error::Error>
1595        {
1596            use std::clone::Clone;
1597            let token = self.0.request.page_token.clone();
1598            let execute = move |token: String| {
1599                let mut builder = self.clone();
1600                builder.0.request = builder.0.request.set_page_token(token);
1601                builder.send()
1602            };
1603            gax::paginator::internal::new_paginator(token, execute)
1604        }
1605
1606        /// Streams each item in the collection.
1607        pub fn by_item(
1608            self,
1609        ) -> impl gax::paginator::ItemPaginator<
1610            crate::model::ListExternalAddressesResponse,
1611            gax::error::Error,
1612        > {
1613            use gax::paginator::Paginator;
1614            self.by_page().items()
1615        }
1616
1617        /// Sets the value of [parent][crate::model::ListExternalAddressesRequest::parent].
1618        ///
1619        /// This is a **required** field for requests.
1620        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
1621            self.0.request.parent = v.into();
1622            self
1623        }
1624
1625        /// Sets the value of [page_size][crate::model::ListExternalAddressesRequest::page_size].
1626        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
1627            self.0.request.page_size = v.into();
1628            self
1629        }
1630
1631        /// Sets the value of [page_token][crate::model::ListExternalAddressesRequest::page_token].
1632        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
1633            self.0.request.page_token = v.into();
1634            self
1635        }
1636
1637        /// Sets the value of [filter][crate::model::ListExternalAddressesRequest::filter].
1638        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
1639            self.0.request.filter = v.into();
1640            self
1641        }
1642
1643        /// Sets the value of [order_by][crate::model::ListExternalAddressesRequest::order_by].
1644        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
1645            self.0.request.order_by = v.into();
1646            self
1647        }
1648    }
1649
1650    #[doc(hidden)]
1651    impl gax::options::internal::RequestBuilder for ListExternalAddresses {
1652        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1653            &mut self.0.options
1654        }
1655    }
1656
1657    /// The request builder for [VmwareEngine::fetch_network_policy_external_addresses][crate::client::VmwareEngine::fetch_network_policy_external_addresses] calls.
1658    ///
1659    /// # Example
1660    /// ```
1661    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::FetchNetworkPolicyExternalAddresses;
1662    /// # async fn sample() -> gax::Result<()> {
1663    /// use gax::paginator::ItemPaginator;
1664    ///
1665    /// let builder = prepare_request_builder();
1666    /// let mut items = builder.by_item();
1667    /// while let Some(result) = items.next().await {
1668    ///   let item = result?;
1669    /// }
1670    /// # Ok(()) }
1671    ///
1672    /// fn prepare_request_builder() -> FetchNetworkPolicyExternalAddresses {
1673    ///   # panic!();
1674    ///   // ... details omitted ...
1675    /// }
1676    /// ```
1677    #[derive(Clone, Debug)]
1678    pub struct FetchNetworkPolicyExternalAddresses(
1679        RequestBuilder<crate::model::FetchNetworkPolicyExternalAddressesRequest>,
1680    );
1681
1682    impl FetchNetworkPolicyExternalAddresses {
1683        pub(crate) fn new(
1684            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
1685        ) -> Self {
1686            Self(RequestBuilder::new(stub))
1687        }
1688
1689        /// Sets the full request, replacing any prior values.
1690        pub fn with_request<V: Into<crate::model::FetchNetworkPolicyExternalAddressesRequest>>(
1691            mut self,
1692            v: V,
1693        ) -> Self {
1694            self.0.request = v.into();
1695            self
1696        }
1697
1698        /// Sets all the options, replacing any prior values.
1699        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1700            self.0.options = v.into();
1701            self
1702        }
1703
1704        /// Sends the request.
1705        pub async fn send(
1706            self,
1707        ) -> Result<crate::model::FetchNetworkPolicyExternalAddressesResponse> {
1708            (*self.0.stub)
1709                .fetch_network_policy_external_addresses(self.0.request, self.0.options)
1710                .await
1711                .map(gax::response::Response::into_body)
1712        }
1713
1714        /// Streams each page in the collection.
1715        pub fn by_page(
1716            self,
1717        ) -> impl gax::paginator::Paginator<
1718            crate::model::FetchNetworkPolicyExternalAddressesResponse,
1719            gax::error::Error,
1720        > {
1721            use std::clone::Clone;
1722            let token = self.0.request.page_token.clone();
1723            let execute = move |token: String| {
1724                let mut builder = self.clone();
1725                builder.0.request = builder.0.request.set_page_token(token);
1726                builder.send()
1727            };
1728            gax::paginator::internal::new_paginator(token, execute)
1729        }
1730
1731        /// Streams each item in the collection.
1732        pub fn by_item(
1733            self,
1734        ) -> impl gax::paginator::ItemPaginator<
1735            crate::model::FetchNetworkPolicyExternalAddressesResponse,
1736            gax::error::Error,
1737        > {
1738            use gax::paginator::Paginator;
1739            self.by_page().items()
1740        }
1741
1742        /// Sets the value of [network_policy][crate::model::FetchNetworkPolicyExternalAddressesRequest::network_policy].
1743        ///
1744        /// This is a **required** field for requests.
1745        pub fn set_network_policy<T: Into<std::string::String>>(mut self, v: T) -> Self {
1746            self.0.request.network_policy = v.into();
1747            self
1748        }
1749
1750        /// Sets the value of [page_size][crate::model::FetchNetworkPolicyExternalAddressesRequest::page_size].
1751        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
1752            self.0.request.page_size = v.into();
1753            self
1754        }
1755
1756        /// Sets the value of [page_token][crate::model::FetchNetworkPolicyExternalAddressesRequest::page_token].
1757        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
1758            self.0.request.page_token = v.into();
1759            self
1760        }
1761    }
1762
1763    #[doc(hidden)]
1764    impl gax::options::internal::RequestBuilder for FetchNetworkPolicyExternalAddresses {
1765        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1766            &mut self.0.options
1767        }
1768    }
1769
1770    /// The request builder for [VmwareEngine::get_external_address][crate::client::VmwareEngine::get_external_address] calls.
1771    ///
1772    /// # Example
1773    /// ```
1774    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetExternalAddress;
1775    /// # async fn sample() -> gax::Result<()> {
1776    ///
1777    /// let builder = prepare_request_builder();
1778    /// let response = builder.send().await?;
1779    /// # Ok(()) }
1780    ///
1781    /// fn prepare_request_builder() -> GetExternalAddress {
1782    ///   # panic!();
1783    ///   // ... details omitted ...
1784    /// }
1785    /// ```
1786    #[derive(Clone, Debug)]
1787    pub struct GetExternalAddress(RequestBuilder<crate::model::GetExternalAddressRequest>);
1788
1789    impl GetExternalAddress {
1790        pub(crate) fn new(
1791            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
1792        ) -> Self {
1793            Self(RequestBuilder::new(stub))
1794        }
1795
1796        /// Sets the full request, replacing any prior values.
1797        pub fn with_request<V: Into<crate::model::GetExternalAddressRequest>>(
1798            mut self,
1799            v: V,
1800        ) -> Self {
1801            self.0.request = v.into();
1802            self
1803        }
1804
1805        /// Sets all the options, replacing any prior values.
1806        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1807            self.0.options = v.into();
1808            self
1809        }
1810
1811        /// Sends the request.
1812        pub async fn send(self) -> Result<crate::model::ExternalAddress> {
1813            (*self.0.stub)
1814                .get_external_address(self.0.request, self.0.options)
1815                .await
1816                .map(gax::response::Response::into_body)
1817        }
1818
1819        /// Sets the value of [name][crate::model::GetExternalAddressRequest::name].
1820        ///
1821        /// This is a **required** field for requests.
1822        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
1823            self.0.request.name = v.into();
1824            self
1825        }
1826    }
1827
1828    #[doc(hidden)]
1829    impl gax::options::internal::RequestBuilder for GetExternalAddress {
1830        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1831            &mut self.0.options
1832        }
1833    }
1834
1835    /// The request builder for [VmwareEngine::create_external_address][crate::client::VmwareEngine::create_external_address] calls.
1836    ///
1837    /// # Example
1838    /// ```
1839    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateExternalAddress;
1840    /// # async fn sample() -> gax::Result<()> {
1841    /// use lro::Poller;
1842    ///
1843    /// let builder = prepare_request_builder();
1844    /// let response = builder.poller().until_done().await?;
1845    /// # Ok(()) }
1846    ///
1847    /// fn prepare_request_builder() -> CreateExternalAddress {
1848    ///   # panic!();
1849    ///   // ... details omitted ...
1850    /// }
1851    /// ```
1852    #[derive(Clone, Debug)]
1853    pub struct CreateExternalAddress(RequestBuilder<crate::model::CreateExternalAddressRequest>);
1854
1855    impl CreateExternalAddress {
1856        pub(crate) fn new(
1857            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
1858        ) -> Self {
1859            Self(RequestBuilder::new(stub))
1860        }
1861
1862        /// Sets the full request, replacing any prior values.
1863        pub fn with_request<V: Into<crate::model::CreateExternalAddressRequest>>(
1864            mut self,
1865            v: V,
1866        ) -> Self {
1867            self.0.request = v.into();
1868            self
1869        }
1870
1871        /// Sets all the options, replacing any prior values.
1872        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
1873            self.0.options = v.into();
1874            self
1875        }
1876
1877        /// Sends the request.
1878        ///
1879        /// # Long running operations
1880        ///
1881        /// This starts, but does not poll, a longrunning operation. More information
1882        /// on [create_external_address][crate::client::VmwareEngine::create_external_address].
1883        pub async fn send(self) -> Result<longrunning::model::Operation> {
1884            (*self.0.stub)
1885                .create_external_address(self.0.request, self.0.options)
1886                .await
1887                .map(gax::response::Response::into_body)
1888        }
1889
1890        /// Creates a [Poller][lro::Poller] to work with `create_external_address`.
1891        pub fn poller(
1892            self,
1893        ) -> impl lro::Poller<crate::model::ExternalAddress, crate::model::OperationMetadata>
1894        {
1895            type Operation = lro::internal::Operation<
1896                crate::model::ExternalAddress,
1897                crate::model::OperationMetadata,
1898            >;
1899            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
1900            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
1901
1902            let stub = self.0.stub.clone();
1903            let mut options = self.0.options.clone();
1904            options.set_retry_policy(gax::retry_policy::NeverRetry);
1905            let query = move |name| {
1906                let stub = stub.clone();
1907                let options = options.clone();
1908                async {
1909                    let op = GetOperation::new(stub)
1910                        .set_name(name)
1911                        .with_options(options)
1912                        .send()
1913                        .await?;
1914                    Ok(Operation::new(op))
1915                }
1916            };
1917
1918            let start = move || async {
1919                let op = self.send().await?;
1920                Ok(Operation::new(op))
1921            };
1922
1923            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
1924        }
1925
1926        /// Sets the value of [parent][crate::model::CreateExternalAddressRequest::parent].
1927        ///
1928        /// This is a **required** field for requests.
1929        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
1930            self.0.request.parent = v.into();
1931            self
1932        }
1933
1934        /// Sets the value of [external_address][crate::model::CreateExternalAddressRequest::external_address].
1935        ///
1936        /// This is a **required** field for requests.
1937        pub fn set_external_address<T>(mut self, v: T) -> Self
1938        where
1939            T: std::convert::Into<crate::model::ExternalAddress>,
1940        {
1941            self.0.request.external_address = std::option::Option::Some(v.into());
1942            self
1943        }
1944
1945        /// Sets or clears the value of [external_address][crate::model::CreateExternalAddressRequest::external_address].
1946        ///
1947        /// This is a **required** field for requests.
1948        pub fn set_or_clear_external_address<T>(mut self, v: std::option::Option<T>) -> Self
1949        where
1950            T: std::convert::Into<crate::model::ExternalAddress>,
1951        {
1952            self.0.request.external_address = v.map(|x| x.into());
1953            self
1954        }
1955
1956        /// Sets the value of [external_address_id][crate::model::CreateExternalAddressRequest::external_address_id].
1957        ///
1958        /// This is a **required** field for requests.
1959        pub fn set_external_address_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
1960            self.0.request.external_address_id = v.into();
1961            self
1962        }
1963
1964        /// Sets the value of [request_id][crate::model::CreateExternalAddressRequest::request_id].
1965        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
1966            self.0.request.request_id = v.into();
1967            self
1968        }
1969    }
1970
1971    #[doc(hidden)]
1972    impl gax::options::internal::RequestBuilder for CreateExternalAddress {
1973        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
1974            &mut self.0.options
1975        }
1976    }
1977
1978    /// The request builder for [VmwareEngine::update_external_address][crate::client::VmwareEngine::update_external_address] calls.
1979    ///
1980    /// # Example
1981    /// ```
1982    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateExternalAddress;
1983    /// # async fn sample() -> gax::Result<()> {
1984    /// use lro::Poller;
1985    ///
1986    /// let builder = prepare_request_builder();
1987    /// let response = builder.poller().until_done().await?;
1988    /// # Ok(()) }
1989    ///
1990    /// fn prepare_request_builder() -> UpdateExternalAddress {
1991    ///   # panic!();
1992    ///   // ... details omitted ...
1993    /// }
1994    /// ```
1995    #[derive(Clone, Debug)]
1996    pub struct UpdateExternalAddress(RequestBuilder<crate::model::UpdateExternalAddressRequest>);
1997
1998    impl UpdateExternalAddress {
1999        pub(crate) fn new(
2000            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2001        ) -> Self {
2002            Self(RequestBuilder::new(stub))
2003        }
2004
2005        /// Sets the full request, replacing any prior values.
2006        pub fn with_request<V: Into<crate::model::UpdateExternalAddressRequest>>(
2007            mut self,
2008            v: V,
2009        ) -> Self {
2010            self.0.request = v.into();
2011            self
2012        }
2013
2014        /// Sets all the options, replacing any prior values.
2015        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2016            self.0.options = v.into();
2017            self
2018        }
2019
2020        /// Sends the request.
2021        ///
2022        /// # Long running operations
2023        ///
2024        /// This starts, but does not poll, a longrunning operation. More information
2025        /// on [update_external_address][crate::client::VmwareEngine::update_external_address].
2026        pub async fn send(self) -> Result<longrunning::model::Operation> {
2027            (*self.0.stub)
2028                .update_external_address(self.0.request, self.0.options)
2029                .await
2030                .map(gax::response::Response::into_body)
2031        }
2032
2033        /// Creates a [Poller][lro::Poller] to work with `update_external_address`.
2034        pub fn poller(
2035            self,
2036        ) -> impl lro::Poller<crate::model::ExternalAddress, crate::model::OperationMetadata>
2037        {
2038            type Operation = lro::internal::Operation<
2039                crate::model::ExternalAddress,
2040                crate::model::OperationMetadata,
2041            >;
2042            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
2043            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
2044
2045            let stub = self.0.stub.clone();
2046            let mut options = self.0.options.clone();
2047            options.set_retry_policy(gax::retry_policy::NeverRetry);
2048            let query = move |name| {
2049                let stub = stub.clone();
2050                let options = options.clone();
2051                async {
2052                    let op = GetOperation::new(stub)
2053                        .set_name(name)
2054                        .with_options(options)
2055                        .send()
2056                        .await?;
2057                    Ok(Operation::new(op))
2058                }
2059            };
2060
2061            let start = move || async {
2062                let op = self.send().await?;
2063                Ok(Operation::new(op))
2064            };
2065
2066            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
2067        }
2068
2069        /// Sets the value of [update_mask][crate::model::UpdateExternalAddressRequest::update_mask].
2070        ///
2071        /// This is a **required** field for requests.
2072        pub fn set_update_mask<T>(mut self, v: T) -> Self
2073        where
2074            T: std::convert::Into<wkt::FieldMask>,
2075        {
2076            self.0.request.update_mask = std::option::Option::Some(v.into());
2077            self
2078        }
2079
2080        /// Sets or clears the value of [update_mask][crate::model::UpdateExternalAddressRequest::update_mask].
2081        ///
2082        /// This is a **required** field for requests.
2083        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
2084        where
2085            T: std::convert::Into<wkt::FieldMask>,
2086        {
2087            self.0.request.update_mask = v.map(|x| x.into());
2088            self
2089        }
2090
2091        /// Sets the value of [external_address][crate::model::UpdateExternalAddressRequest::external_address].
2092        ///
2093        /// This is a **required** field for requests.
2094        pub fn set_external_address<T>(mut self, v: T) -> Self
2095        where
2096            T: std::convert::Into<crate::model::ExternalAddress>,
2097        {
2098            self.0.request.external_address = std::option::Option::Some(v.into());
2099            self
2100        }
2101
2102        /// Sets or clears the value of [external_address][crate::model::UpdateExternalAddressRequest::external_address].
2103        ///
2104        /// This is a **required** field for requests.
2105        pub fn set_or_clear_external_address<T>(mut self, v: std::option::Option<T>) -> Self
2106        where
2107            T: std::convert::Into<crate::model::ExternalAddress>,
2108        {
2109            self.0.request.external_address = v.map(|x| x.into());
2110            self
2111        }
2112
2113        /// Sets the value of [request_id][crate::model::UpdateExternalAddressRequest::request_id].
2114        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
2115            self.0.request.request_id = v.into();
2116            self
2117        }
2118    }
2119
2120    #[doc(hidden)]
2121    impl gax::options::internal::RequestBuilder for UpdateExternalAddress {
2122        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
2123            &mut self.0.options
2124        }
2125    }
2126
2127    /// The request builder for [VmwareEngine::delete_external_address][crate::client::VmwareEngine::delete_external_address] calls.
2128    ///
2129    /// # Example
2130    /// ```
2131    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteExternalAddress;
2132    /// # async fn sample() -> gax::Result<()> {
2133    /// use lro::Poller;
2134    ///
2135    /// let builder = prepare_request_builder();
2136    /// let response = builder.poller().until_done().await?;
2137    /// # Ok(()) }
2138    ///
2139    /// fn prepare_request_builder() -> DeleteExternalAddress {
2140    ///   # panic!();
2141    ///   // ... details omitted ...
2142    /// }
2143    /// ```
2144    #[derive(Clone, Debug)]
2145    pub struct DeleteExternalAddress(RequestBuilder<crate::model::DeleteExternalAddressRequest>);
2146
2147    impl DeleteExternalAddress {
2148        pub(crate) fn new(
2149            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2150        ) -> Self {
2151            Self(RequestBuilder::new(stub))
2152        }
2153
2154        /// Sets the full request, replacing any prior values.
2155        pub fn with_request<V: Into<crate::model::DeleteExternalAddressRequest>>(
2156            mut self,
2157            v: V,
2158        ) -> Self {
2159            self.0.request = v.into();
2160            self
2161        }
2162
2163        /// Sets all the options, replacing any prior values.
2164        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2165            self.0.options = v.into();
2166            self
2167        }
2168
2169        /// Sends the request.
2170        ///
2171        /// # Long running operations
2172        ///
2173        /// This starts, but does not poll, a longrunning operation. More information
2174        /// on [delete_external_address][crate::client::VmwareEngine::delete_external_address].
2175        pub async fn send(self) -> Result<longrunning::model::Operation> {
2176            (*self.0.stub)
2177                .delete_external_address(self.0.request, self.0.options)
2178                .await
2179                .map(gax::response::Response::into_body)
2180        }
2181
2182        /// Creates a [Poller][lro::Poller] to work with `delete_external_address`.
2183        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
2184            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
2185            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
2186            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
2187
2188            let stub = self.0.stub.clone();
2189            let mut options = self.0.options.clone();
2190            options.set_retry_policy(gax::retry_policy::NeverRetry);
2191            let query = move |name| {
2192                let stub = stub.clone();
2193                let options = options.clone();
2194                async {
2195                    let op = GetOperation::new(stub)
2196                        .set_name(name)
2197                        .with_options(options)
2198                        .send()
2199                        .await?;
2200                    Ok(Operation::new(op))
2201                }
2202            };
2203
2204            let start = move || async {
2205                let op = self.send().await?;
2206                Ok(Operation::new(op))
2207            };
2208
2209            lro::internal::new_unit_response_poller(
2210                polling_error_policy,
2211                polling_backoff_policy,
2212                start,
2213                query,
2214            )
2215        }
2216
2217        /// Sets the value of [name][crate::model::DeleteExternalAddressRequest::name].
2218        ///
2219        /// This is a **required** field for requests.
2220        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
2221            self.0.request.name = v.into();
2222            self
2223        }
2224
2225        /// Sets the value of [request_id][crate::model::DeleteExternalAddressRequest::request_id].
2226        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
2227            self.0.request.request_id = v.into();
2228            self
2229        }
2230    }
2231
2232    #[doc(hidden)]
2233    impl gax::options::internal::RequestBuilder for DeleteExternalAddress {
2234        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
2235            &mut self.0.options
2236        }
2237    }
2238
2239    /// The request builder for [VmwareEngine::list_subnets][crate::client::VmwareEngine::list_subnets] calls.
2240    ///
2241    /// # Example
2242    /// ```
2243    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListSubnets;
2244    /// # async fn sample() -> gax::Result<()> {
2245    /// use gax::paginator::ItemPaginator;
2246    ///
2247    /// let builder = prepare_request_builder();
2248    /// let mut items = builder.by_item();
2249    /// while let Some(result) = items.next().await {
2250    ///   let item = result?;
2251    /// }
2252    /// # Ok(()) }
2253    ///
2254    /// fn prepare_request_builder() -> ListSubnets {
2255    ///   # panic!();
2256    ///   // ... details omitted ...
2257    /// }
2258    /// ```
2259    #[derive(Clone, Debug)]
2260    pub struct ListSubnets(RequestBuilder<crate::model::ListSubnetsRequest>);
2261
2262    impl ListSubnets {
2263        pub(crate) fn new(
2264            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2265        ) -> Self {
2266            Self(RequestBuilder::new(stub))
2267        }
2268
2269        /// Sets the full request, replacing any prior values.
2270        pub fn with_request<V: Into<crate::model::ListSubnetsRequest>>(mut self, v: V) -> Self {
2271            self.0.request = v.into();
2272            self
2273        }
2274
2275        /// Sets all the options, replacing any prior values.
2276        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2277            self.0.options = v.into();
2278            self
2279        }
2280
2281        /// Sends the request.
2282        pub async fn send(self) -> Result<crate::model::ListSubnetsResponse> {
2283            (*self.0.stub)
2284                .list_subnets(self.0.request, self.0.options)
2285                .await
2286                .map(gax::response::Response::into_body)
2287        }
2288
2289        /// Streams each page in the collection.
2290        pub fn by_page(
2291            self,
2292        ) -> impl gax::paginator::Paginator<crate::model::ListSubnetsResponse, gax::error::Error>
2293        {
2294            use std::clone::Clone;
2295            let token = self.0.request.page_token.clone();
2296            let execute = move |token: String| {
2297                let mut builder = self.clone();
2298                builder.0.request = builder.0.request.set_page_token(token);
2299                builder.send()
2300            };
2301            gax::paginator::internal::new_paginator(token, execute)
2302        }
2303
2304        /// Streams each item in the collection.
2305        pub fn by_item(
2306            self,
2307        ) -> impl gax::paginator::ItemPaginator<crate::model::ListSubnetsResponse, gax::error::Error>
2308        {
2309            use gax::paginator::Paginator;
2310            self.by_page().items()
2311        }
2312
2313        /// Sets the value of [parent][crate::model::ListSubnetsRequest::parent].
2314        ///
2315        /// This is a **required** field for requests.
2316        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
2317            self.0.request.parent = v.into();
2318            self
2319        }
2320
2321        /// Sets the value of [page_size][crate::model::ListSubnetsRequest::page_size].
2322        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
2323            self.0.request.page_size = v.into();
2324            self
2325        }
2326
2327        /// Sets the value of [page_token][crate::model::ListSubnetsRequest::page_token].
2328        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
2329            self.0.request.page_token = v.into();
2330            self
2331        }
2332    }
2333
2334    #[doc(hidden)]
2335    impl gax::options::internal::RequestBuilder for ListSubnets {
2336        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
2337            &mut self.0.options
2338        }
2339    }
2340
2341    /// The request builder for [VmwareEngine::get_subnet][crate::client::VmwareEngine::get_subnet] calls.
2342    ///
2343    /// # Example
2344    /// ```
2345    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetSubnet;
2346    /// # async fn sample() -> gax::Result<()> {
2347    ///
2348    /// let builder = prepare_request_builder();
2349    /// let response = builder.send().await?;
2350    /// # Ok(()) }
2351    ///
2352    /// fn prepare_request_builder() -> GetSubnet {
2353    ///   # panic!();
2354    ///   // ... details omitted ...
2355    /// }
2356    /// ```
2357    #[derive(Clone, Debug)]
2358    pub struct GetSubnet(RequestBuilder<crate::model::GetSubnetRequest>);
2359
2360    impl GetSubnet {
2361        pub(crate) fn new(
2362            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2363        ) -> Self {
2364            Self(RequestBuilder::new(stub))
2365        }
2366
2367        /// Sets the full request, replacing any prior values.
2368        pub fn with_request<V: Into<crate::model::GetSubnetRequest>>(mut self, v: V) -> Self {
2369            self.0.request = v.into();
2370            self
2371        }
2372
2373        /// Sets all the options, replacing any prior values.
2374        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2375            self.0.options = v.into();
2376            self
2377        }
2378
2379        /// Sends the request.
2380        pub async fn send(self) -> Result<crate::model::Subnet> {
2381            (*self.0.stub)
2382                .get_subnet(self.0.request, self.0.options)
2383                .await
2384                .map(gax::response::Response::into_body)
2385        }
2386
2387        /// Sets the value of [name][crate::model::GetSubnetRequest::name].
2388        ///
2389        /// This is a **required** field for requests.
2390        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
2391            self.0.request.name = v.into();
2392            self
2393        }
2394    }
2395
2396    #[doc(hidden)]
2397    impl gax::options::internal::RequestBuilder for GetSubnet {
2398        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
2399            &mut self.0.options
2400        }
2401    }
2402
2403    /// The request builder for [VmwareEngine::update_subnet][crate::client::VmwareEngine::update_subnet] calls.
2404    ///
2405    /// # Example
2406    /// ```
2407    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateSubnet;
2408    /// # async fn sample() -> gax::Result<()> {
2409    /// use lro::Poller;
2410    ///
2411    /// let builder = prepare_request_builder();
2412    /// let response = builder.poller().until_done().await?;
2413    /// # Ok(()) }
2414    ///
2415    /// fn prepare_request_builder() -> UpdateSubnet {
2416    ///   # panic!();
2417    ///   // ... details omitted ...
2418    /// }
2419    /// ```
2420    #[derive(Clone, Debug)]
2421    pub struct UpdateSubnet(RequestBuilder<crate::model::UpdateSubnetRequest>);
2422
2423    impl UpdateSubnet {
2424        pub(crate) fn new(
2425            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2426        ) -> Self {
2427            Self(RequestBuilder::new(stub))
2428        }
2429
2430        /// Sets the full request, replacing any prior values.
2431        pub fn with_request<V: Into<crate::model::UpdateSubnetRequest>>(mut self, v: V) -> Self {
2432            self.0.request = v.into();
2433            self
2434        }
2435
2436        /// Sets all the options, replacing any prior values.
2437        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2438            self.0.options = v.into();
2439            self
2440        }
2441
2442        /// Sends the request.
2443        ///
2444        /// # Long running operations
2445        ///
2446        /// This starts, but does not poll, a longrunning operation. More information
2447        /// on [update_subnet][crate::client::VmwareEngine::update_subnet].
2448        pub async fn send(self) -> Result<longrunning::model::Operation> {
2449            (*self.0.stub)
2450                .update_subnet(self.0.request, self.0.options)
2451                .await
2452                .map(gax::response::Response::into_body)
2453        }
2454
2455        /// Creates a [Poller][lro::Poller] to work with `update_subnet`.
2456        pub fn poller(
2457            self,
2458        ) -> impl lro::Poller<crate::model::Subnet, crate::model::OperationMetadata> {
2459            type Operation =
2460                lro::internal::Operation<crate::model::Subnet, crate::model::OperationMetadata>;
2461            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
2462            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
2463
2464            let stub = self.0.stub.clone();
2465            let mut options = self.0.options.clone();
2466            options.set_retry_policy(gax::retry_policy::NeverRetry);
2467            let query = move |name| {
2468                let stub = stub.clone();
2469                let options = options.clone();
2470                async {
2471                    let op = GetOperation::new(stub)
2472                        .set_name(name)
2473                        .with_options(options)
2474                        .send()
2475                        .await?;
2476                    Ok(Operation::new(op))
2477                }
2478            };
2479
2480            let start = move || async {
2481                let op = self.send().await?;
2482                Ok(Operation::new(op))
2483            };
2484
2485            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
2486        }
2487
2488        /// Sets the value of [update_mask][crate::model::UpdateSubnetRequest::update_mask].
2489        ///
2490        /// This is a **required** field for requests.
2491        pub fn set_update_mask<T>(mut self, v: T) -> Self
2492        where
2493            T: std::convert::Into<wkt::FieldMask>,
2494        {
2495            self.0.request.update_mask = std::option::Option::Some(v.into());
2496            self
2497        }
2498
2499        /// Sets or clears the value of [update_mask][crate::model::UpdateSubnetRequest::update_mask].
2500        ///
2501        /// This is a **required** field for requests.
2502        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
2503        where
2504            T: std::convert::Into<wkt::FieldMask>,
2505        {
2506            self.0.request.update_mask = v.map(|x| x.into());
2507            self
2508        }
2509
2510        /// Sets the value of [subnet][crate::model::UpdateSubnetRequest::subnet].
2511        ///
2512        /// This is a **required** field for requests.
2513        pub fn set_subnet<T>(mut self, v: T) -> Self
2514        where
2515            T: std::convert::Into<crate::model::Subnet>,
2516        {
2517            self.0.request.subnet = std::option::Option::Some(v.into());
2518            self
2519        }
2520
2521        /// Sets or clears the value of [subnet][crate::model::UpdateSubnetRequest::subnet].
2522        ///
2523        /// This is a **required** field for requests.
2524        pub fn set_or_clear_subnet<T>(mut self, v: std::option::Option<T>) -> Self
2525        where
2526            T: std::convert::Into<crate::model::Subnet>,
2527        {
2528            self.0.request.subnet = v.map(|x| x.into());
2529            self
2530        }
2531    }
2532
2533    #[doc(hidden)]
2534    impl gax::options::internal::RequestBuilder for UpdateSubnet {
2535        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
2536            &mut self.0.options
2537        }
2538    }
2539
2540    /// The request builder for [VmwareEngine::list_external_access_rules][crate::client::VmwareEngine::list_external_access_rules] calls.
2541    ///
2542    /// # Example
2543    /// ```
2544    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListExternalAccessRules;
2545    /// # async fn sample() -> gax::Result<()> {
2546    /// use gax::paginator::ItemPaginator;
2547    ///
2548    /// let builder = prepare_request_builder();
2549    /// let mut items = builder.by_item();
2550    /// while let Some(result) = items.next().await {
2551    ///   let item = result?;
2552    /// }
2553    /// # Ok(()) }
2554    ///
2555    /// fn prepare_request_builder() -> ListExternalAccessRules {
2556    ///   # panic!();
2557    ///   // ... details omitted ...
2558    /// }
2559    /// ```
2560    #[derive(Clone, Debug)]
2561    pub struct ListExternalAccessRules(
2562        RequestBuilder<crate::model::ListExternalAccessRulesRequest>,
2563    );
2564
2565    impl ListExternalAccessRules {
2566        pub(crate) fn new(
2567            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2568        ) -> Self {
2569            Self(RequestBuilder::new(stub))
2570        }
2571
2572        /// Sets the full request, replacing any prior values.
2573        pub fn with_request<V: Into<crate::model::ListExternalAccessRulesRequest>>(
2574            mut self,
2575            v: V,
2576        ) -> Self {
2577            self.0.request = v.into();
2578            self
2579        }
2580
2581        /// Sets all the options, replacing any prior values.
2582        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2583            self.0.options = v.into();
2584            self
2585        }
2586
2587        /// Sends the request.
2588        pub async fn send(self) -> Result<crate::model::ListExternalAccessRulesResponse> {
2589            (*self.0.stub)
2590                .list_external_access_rules(self.0.request, self.0.options)
2591                .await
2592                .map(gax::response::Response::into_body)
2593        }
2594
2595        /// Streams each page in the collection.
2596        pub fn by_page(
2597            self,
2598        ) -> impl gax::paginator::Paginator<
2599            crate::model::ListExternalAccessRulesResponse,
2600            gax::error::Error,
2601        > {
2602            use std::clone::Clone;
2603            let token = self.0.request.page_token.clone();
2604            let execute = move |token: String| {
2605                let mut builder = self.clone();
2606                builder.0.request = builder.0.request.set_page_token(token);
2607                builder.send()
2608            };
2609            gax::paginator::internal::new_paginator(token, execute)
2610        }
2611
2612        /// Streams each item in the collection.
2613        pub fn by_item(
2614            self,
2615        ) -> impl gax::paginator::ItemPaginator<
2616            crate::model::ListExternalAccessRulesResponse,
2617            gax::error::Error,
2618        > {
2619            use gax::paginator::Paginator;
2620            self.by_page().items()
2621        }
2622
2623        /// Sets the value of [parent][crate::model::ListExternalAccessRulesRequest::parent].
2624        ///
2625        /// This is a **required** field for requests.
2626        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
2627            self.0.request.parent = v.into();
2628            self
2629        }
2630
2631        /// Sets the value of [page_size][crate::model::ListExternalAccessRulesRequest::page_size].
2632        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
2633            self.0.request.page_size = v.into();
2634            self
2635        }
2636
2637        /// Sets the value of [page_token][crate::model::ListExternalAccessRulesRequest::page_token].
2638        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
2639            self.0.request.page_token = v.into();
2640            self
2641        }
2642
2643        /// Sets the value of [filter][crate::model::ListExternalAccessRulesRequest::filter].
2644        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
2645            self.0.request.filter = v.into();
2646            self
2647        }
2648
2649        /// Sets the value of [order_by][crate::model::ListExternalAccessRulesRequest::order_by].
2650        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
2651            self.0.request.order_by = v.into();
2652            self
2653        }
2654    }
2655
2656    #[doc(hidden)]
2657    impl gax::options::internal::RequestBuilder for ListExternalAccessRules {
2658        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
2659            &mut self.0.options
2660        }
2661    }
2662
2663    /// The request builder for [VmwareEngine::get_external_access_rule][crate::client::VmwareEngine::get_external_access_rule] calls.
2664    ///
2665    /// # Example
2666    /// ```
2667    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetExternalAccessRule;
2668    /// # async fn sample() -> gax::Result<()> {
2669    ///
2670    /// let builder = prepare_request_builder();
2671    /// let response = builder.send().await?;
2672    /// # Ok(()) }
2673    ///
2674    /// fn prepare_request_builder() -> GetExternalAccessRule {
2675    ///   # panic!();
2676    ///   // ... details omitted ...
2677    /// }
2678    /// ```
2679    #[derive(Clone, Debug)]
2680    pub struct GetExternalAccessRule(RequestBuilder<crate::model::GetExternalAccessRuleRequest>);
2681
2682    impl GetExternalAccessRule {
2683        pub(crate) fn new(
2684            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2685        ) -> Self {
2686            Self(RequestBuilder::new(stub))
2687        }
2688
2689        /// Sets the full request, replacing any prior values.
2690        pub fn with_request<V: Into<crate::model::GetExternalAccessRuleRequest>>(
2691            mut self,
2692            v: V,
2693        ) -> Self {
2694            self.0.request = v.into();
2695            self
2696        }
2697
2698        /// Sets all the options, replacing any prior values.
2699        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2700            self.0.options = v.into();
2701            self
2702        }
2703
2704        /// Sends the request.
2705        pub async fn send(self) -> Result<crate::model::ExternalAccessRule> {
2706            (*self.0.stub)
2707                .get_external_access_rule(self.0.request, self.0.options)
2708                .await
2709                .map(gax::response::Response::into_body)
2710        }
2711
2712        /// Sets the value of [name][crate::model::GetExternalAccessRuleRequest::name].
2713        ///
2714        /// This is a **required** field for requests.
2715        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
2716            self.0.request.name = v.into();
2717            self
2718        }
2719    }
2720
2721    #[doc(hidden)]
2722    impl gax::options::internal::RequestBuilder for GetExternalAccessRule {
2723        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
2724            &mut self.0.options
2725        }
2726    }
2727
2728    /// The request builder for [VmwareEngine::create_external_access_rule][crate::client::VmwareEngine::create_external_access_rule] calls.
2729    ///
2730    /// # Example
2731    /// ```
2732    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateExternalAccessRule;
2733    /// # async fn sample() -> gax::Result<()> {
2734    /// use lro::Poller;
2735    ///
2736    /// let builder = prepare_request_builder();
2737    /// let response = builder.poller().until_done().await?;
2738    /// # Ok(()) }
2739    ///
2740    /// fn prepare_request_builder() -> CreateExternalAccessRule {
2741    ///   # panic!();
2742    ///   // ... details omitted ...
2743    /// }
2744    /// ```
2745    #[derive(Clone, Debug)]
2746    pub struct CreateExternalAccessRule(
2747        RequestBuilder<crate::model::CreateExternalAccessRuleRequest>,
2748    );
2749
2750    impl CreateExternalAccessRule {
2751        pub(crate) fn new(
2752            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2753        ) -> Self {
2754            Self(RequestBuilder::new(stub))
2755        }
2756
2757        /// Sets the full request, replacing any prior values.
2758        pub fn with_request<V: Into<crate::model::CreateExternalAccessRuleRequest>>(
2759            mut self,
2760            v: V,
2761        ) -> Self {
2762            self.0.request = v.into();
2763            self
2764        }
2765
2766        /// Sets all the options, replacing any prior values.
2767        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2768            self.0.options = v.into();
2769            self
2770        }
2771
2772        /// Sends the request.
2773        ///
2774        /// # Long running operations
2775        ///
2776        /// This starts, but does not poll, a longrunning operation. More information
2777        /// on [create_external_access_rule][crate::client::VmwareEngine::create_external_access_rule].
2778        pub async fn send(self) -> Result<longrunning::model::Operation> {
2779            (*self.0.stub)
2780                .create_external_access_rule(self.0.request, self.0.options)
2781                .await
2782                .map(gax::response::Response::into_body)
2783        }
2784
2785        /// Creates a [Poller][lro::Poller] to work with `create_external_access_rule`.
2786        pub fn poller(
2787            self,
2788        ) -> impl lro::Poller<crate::model::ExternalAccessRule, crate::model::OperationMetadata>
2789        {
2790            type Operation = lro::internal::Operation<
2791                crate::model::ExternalAccessRule,
2792                crate::model::OperationMetadata,
2793            >;
2794            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
2795            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
2796
2797            let stub = self.0.stub.clone();
2798            let mut options = self.0.options.clone();
2799            options.set_retry_policy(gax::retry_policy::NeverRetry);
2800            let query = move |name| {
2801                let stub = stub.clone();
2802                let options = options.clone();
2803                async {
2804                    let op = GetOperation::new(stub)
2805                        .set_name(name)
2806                        .with_options(options)
2807                        .send()
2808                        .await?;
2809                    Ok(Operation::new(op))
2810                }
2811            };
2812
2813            let start = move || async {
2814                let op = self.send().await?;
2815                Ok(Operation::new(op))
2816            };
2817
2818            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
2819        }
2820
2821        /// Sets the value of [parent][crate::model::CreateExternalAccessRuleRequest::parent].
2822        ///
2823        /// This is a **required** field for requests.
2824        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
2825            self.0.request.parent = v.into();
2826            self
2827        }
2828
2829        /// Sets the value of [external_access_rule][crate::model::CreateExternalAccessRuleRequest::external_access_rule].
2830        ///
2831        /// This is a **required** field for requests.
2832        pub fn set_external_access_rule<T>(mut self, v: T) -> Self
2833        where
2834            T: std::convert::Into<crate::model::ExternalAccessRule>,
2835        {
2836            self.0.request.external_access_rule = std::option::Option::Some(v.into());
2837            self
2838        }
2839
2840        /// Sets or clears the value of [external_access_rule][crate::model::CreateExternalAccessRuleRequest::external_access_rule].
2841        ///
2842        /// This is a **required** field for requests.
2843        pub fn set_or_clear_external_access_rule<T>(mut self, v: std::option::Option<T>) -> Self
2844        where
2845            T: std::convert::Into<crate::model::ExternalAccessRule>,
2846        {
2847            self.0.request.external_access_rule = v.map(|x| x.into());
2848            self
2849        }
2850
2851        /// Sets the value of [external_access_rule_id][crate::model::CreateExternalAccessRuleRequest::external_access_rule_id].
2852        ///
2853        /// This is a **required** field for requests.
2854        pub fn set_external_access_rule_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
2855            self.0.request.external_access_rule_id = v.into();
2856            self
2857        }
2858
2859        /// Sets the value of [request_id][crate::model::CreateExternalAccessRuleRequest::request_id].
2860        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
2861            self.0.request.request_id = v.into();
2862            self
2863        }
2864    }
2865
2866    #[doc(hidden)]
2867    impl gax::options::internal::RequestBuilder for CreateExternalAccessRule {
2868        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
2869            &mut self.0.options
2870        }
2871    }
2872
2873    /// The request builder for [VmwareEngine::update_external_access_rule][crate::client::VmwareEngine::update_external_access_rule] calls.
2874    ///
2875    /// # Example
2876    /// ```
2877    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateExternalAccessRule;
2878    /// # async fn sample() -> gax::Result<()> {
2879    /// use lro::Poller;
2880    ///
2881    /// let builder = prepare_request_builder();
2882    /// let response = builder.poller().until_done().await?;
2883    /// # Ok(()) }
2884    ///
2885    /// fn prepare_request_builder() -> UpdateExternalAccessRule {
2886    ///   # panic!();
2887    ///   // ... details omitted ...
2888    /// }
2889    /// ```
2890    #[derive(Clone, Debug)]
2891    pub struct UpdateExternalAccessRule(
2892        RequestBuilder<crate::model::UpdateExternalAccessRuleRequest>,
2893    );
2894
2895    impl UpdateExternalAccessRule {
2896        pub(crate) fn new(
2897            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
2898        ) -> Self {
2899            Self(RequestBuilder::new(stub))
2900        }
2901
2902        /// Sets the full request, replacing any prior values.
2903        pub fn with_request<V: Into<crate::model::UpdateExternalAccessRuleRequest>>(
2904            mut self,
2905            v: V,
2906        ) -> Self {
2907            self.0.request = v.into();
2908            self
2909        }
2910
2911        /// Sets all the options, replacing any prior values.
2912        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
2913            self.0.options = v.into();
2914            self
2915        }
2916
2917        /// Sends the request.
2918        ///
2919        /// # Long running operations
2920        ///
2921        /// This starts, but does not poll, a longrunning operation. More information
2922        /// on [update_external_access_rule][crate::client::VmwareEngine::update_external_access_rule].
2923        pub async fn send(self) -> Result<longrunning::model::Operation> {
2924            (*self.0.stub)
2925                .update_external_access_rule(self.0.request, self.0.options)
2926                .await
2927                .map(gax::response::Response::into_body)
2928        }
2929
2930        /// Creates a [Poller][lro::Poller] to work with `update_external_access_rule`.
2931        pub fn poller(
2932            self,
2933        ) -> impl lro::Poller<crate::model::ExternalAccessRule, crate::model::OperationMetadata>
2934        {
2935            type Operation = lro::internal::Operation<
2936                crate::model::ExternalAccessRule,
2937                crate::model::OperationMetadata,
2938            >;
2939            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
2940            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
2941
2942            let stub = self.0.stub.clone();
2943            let mut options = self.0.options.clone();
2944            options.set_retry_policy(gax::retry_policy::NeverRetry);
2945            let query = move |name| {
2946                let stub = stub.clone();
2947                let options = options.clone();
2948                async {
2949                    let op = GetOperation::new(stub)
2950                        .set_name(name)
2951                        .with_options(options)
2952                        .send()
2953                        .await?;
2954                    Ok(Operation::new(op))
2955                }
2956            };
2957
2958            let start = move || async {
2959                let op = self.send().await?;
2960                Ok(Operation::new(op))
2961            };
2962
2963            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
2964        }
2965
2966        /// Sets the value of [update_mask][crate::model::UpdateExternalAccessRuleRequest::update_mask].
2967        ///
2968        /// This is a **required** field for requests.
2969        pub fn set_update_mask<T>(mut self, v: T) -> Self
2970        where
2971            T: std::convert::Into<wkt::FieldMask>,
2972        {
2973            self.0.request.update_mask = std::option::Option::Some(v.into());
2974            self
2975        }
2976
2977        /// Sets or clears the value of [update_mask][crate::model::UpdateExternalAccessRuleRequest::update_mask].
2978        ///
2979        /// This is a **required** field for requests.
2980        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
2981        where
2982            T: std::convert::Into<wkt::FieldMask>,
2983        {
2984            self.0.request.update_mask = v.map(|x| x.into());
2985            self
2986        }
2987
2988        /// Sets the value of [external_access_rule][crate::model::UpdateExternalAccessRuleRequest::external_access_rule].
2989        ///
2990        /// This is a **required** field for requests.
2991        pub fn set_external_access_rule<T>(mut self, v: T) -> Self
2992        where
2993            T: std::convert::Into<crate::model::ExternalAccessRule>,
2994        {
2995            self.0.request.external_access_rule = std::option::Option::Some(v.into());
2996            self
2997        }
2998
2999        /// Sets or clears the value of [external_access_rule][crate::model::UpdateExternalAccessRuleRequest::external_access_rule].
3000        ///
3001        /// This is a **required** field for requests.
3002        pub fn set_or_clear_external_access_rule<T>(mut self, v: std::option::Option<T>) -> Self
3003        where
3004            T: std::convert::Into<crate::model::ExternalAccessRule>,
3005        {
3006            self.0.request.external_access_rule = v.map(|x| x.into());
3007            self
3008        }
3009
3010        /// Sets the value of [request_id][crate::model::UpdateExternalAccessRuleRequest::request_id].
3011        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
3012            self.0.request.request_id = v.into();
3013            self
3014        }
3015    }
3016
3017    #[doc(hidden)]
3018    impl gax::options::internal::RequestBuilder for UpdateExternalAccessRule {
3019        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3020            &mut self.0.options
3021        }
3022    }
3023
3024    /// The request builder for [VmwareEngine::delete_external_access_rule][crate::client::VmwareEngine::delete_external_access_rule] calls.
3025    ///
3026    /// # Example
3027    /// ```
3028    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteExternalAccessRule;
3029    /// # async fn sample() -> gax::Result<()> {
3030    /// use lro::Poller;
3031    ///
3032    /// let builder = prepare_request_builder();
3033    /// let response = builder.poller().until_done().await?;
3034    /// # Ok(()) }
3035    ///
3036    /// fn prepare_request_builder() -> DeleteExternalAccessRule {
3037    ///   # panic!();
3038    ///   // ... details omitted ...
3039    /// }
3040    /// ```
3041    #[derive(Clone, Debug)]
3042    pub struct DeleteExternalAccessRule(
3043        RequestBuilder<crate::model::DeleteExternalAccessRuleRequest>,
3044    );
3045
3046    impl DeleteExternalAccessRule {
3047        pub(crate) fn new(
3048            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3049        ) -> Self {
3050            Self(RequestBuilder::new(stub))
3051        }
3052
3053        /// Sets the full request, replacing any prior values.
3054        pub fn with_request<V: Into<crate::model::DeleteExternalAccessRuleRequest>>(
3055            mut self,
3056            v: V,
3057        ) -> Self {
3058            self.0.request = v.into();
3059            self
3060        }
3061
3062        /// Sets all the options, replacing any prior values.
3063        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3064            self.0.options = v.into();
3065            self
3066        }
3067
3068        /// Sends the request.
3069        ///
3070        /// # Long running operations
3071        ///
3072        /// This starts, but does not poll, a longrunning operation. More information
3073        /// on [delete_external_access_rule][crate::client::VmwareEngine::delete_external_access_rule].
3074        pub async fn send(self) -> Result<longrunning::model::Operation> {
3075            (*self.0.stub)
3076                .delete_external_access_rule(self.0.request, self.0.options)
3077                .await
3078                .map(gax::response::Response::into_body)
3079        }
3080
3081        /// Creates a [Poller][lro::Poller] to work with `delete_external_access_rule`.
3082        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
3083            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
3084            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
3085            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
3086
3087            let stub = self.0.stub.clone();
3088            let mut options = self.0.options.clone();
3089            options.set_retry_policy(gax::retry_policy::NeverRetry);
3090            let query = move |name| {
3091                let stub = stub.clone();
3092                let options = options.clone();
3093                async {
3094                    let op = GetOperation::new(stub)
3095                        .set_name(name)
3096                        .with_options(options)
3097                        .send()
3098                        .await?;
3099                    Ok(Operation::new(op))
3100                }
3101            };
3102
3103            let start = move || async {
3104                let op = self.send().await?;
3105                Ok(Operation::new(op))
3106            };
3107
3108            lro::internal::new_unit_response_poller(
3109                polling_error_policy,
3110                polling_backoff_policy,
3111                start,
3112                query,
3113            )
3114        }
3115
3116        /// Sets the value of [name][crate::model::DeleteExternalAccessRuleRequest::name].
3117        ///
3118        /// This is a **required** field for requests.
3119        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
3120            self.0.request.name = v.into();
3121            self
3122        }
3123
3124        /// Sets the value of [request_id][crate::model::DeleteExternalAccessRuleRequest::request_id].
3125        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
3126            self.0.request.request_id = v.into();
3127            self
3128        }
3129    }
3130
3131    #[doc(hidden)]
3132    impl gax::options::internal::RequestBuilder for DeleteExternalAccessRule {
3133        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3134            &mut self.0.options
3135        }
3136    }
3137
3138    /// The request builder for [VmwareEngine::list_logging_servers][crate::client::VmwareEngine::list_logging_servers] calls.
3139    ///
3140    /// # Example
3141    /// ```
3142    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListLoggingServers;
3143    /// # async fn sample() -> gax::Result<()> {
3144    /// use gax::paginator::ItemPaginator;
3145    ///
3146    /// let builder = prepare_request_builder();
3147    /// let mut items = builder.by_item();
3148    /// while let Some(result) = items.next().await {
3149    ///   let item = result?;
3150    /// }
3151    /// # Ok(()) }
3152    ///
3153    /// fn prepare_request_builder() -> ListLoggingServers {
3154    ///   # panic!();
3155    ///   // ... details omitted ...
3156    /// }
3157    /// ```
3158    #[derive(Clone, Debug)]
3159    pub struct ListLoggingServers(RequestBuilder<crate::model::ListLoggingServersRequest>);
3160
3161    impl ListLoggingServers {
3162        pub(crate) fn new(
3163            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3164        ) -> Self {
3165            Self(RequestBuilder::new(stub))
3166        }
3167
3168        /// Sets the full request, replacing any prior values.
3169        pub fn with_request<V: Into<crate::model::ListLoggingServersRequest>>(
3170            mut self,
3171            v: V,
3172        ) -> Self {
3173            self.0.request = v.into();
3174            self
3175        }
3176
3177        /// Sets all the options, replacing any prior values.
3178        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3179            self.0.options = v.into();
3180            self
3181        }
3182
3183        /// Sends the request.
3184        pub async fn send(self) -> Result<crate::model::ListLoggingServersResponse> {
3185            (*self.0.stub)
3186                .list_logging_servers(self.0.request, self.0.options)
3187                .await
3188                .map(gax::response::Response::into_body)
3189        }
3190
3191        /// Streams each page in the collection.
3192        pub fn by_page(
3193            self,
3194        ) -> impl gax::paginator::Paginator<crate::model::ListLoggingServersResponse, gax::error::Error>
3195        {
3196            use std::clone::Clone;
3197            let token = self.0.request.page_token.clone();
3198            let execute = move |token: String| {
3199                let mut builder = self.clone();
3200                builder.0.request = builder.0.request.set_page_token(token);
3201                builder.send()
3202            };
3203            gax::paginator::internal::new_paginator(token, execute)
3204        }
3205
3206        /// Streams each item in the collection.
3207        pub fn by_item(
3208            self,
3209        ) -> impl gax::paginator::ItemPaginator<
3210            crate::model::ListLoggingServersResponse,
3211            gax::error::Error,
3212        > {
3213            use gax::paginator::Paginator;
3214            self.by_page().items()
3215        }
3216
3217        /// Sets the value of [parent][crate::model::ListLoggingServersRequest::parent].
3218        ///
3219        /// This is a **required** field for requests.
3220        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
3221            self.0.request.parent = v.into();
3222            self
3223        }
3224
3225        /// Sets the value of [page_size][crate::model::ListLoggingServersRequest::page_size].
3226        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
3227            self.0.request.page_size = v.into();
3228            self
3229        }
3230
3231        /// Sets the value of [page_token][crate::model::ListLoggingServersRequest::page_token].
3232        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
3233            self.0.request.page_token = v.into();
3234            self
3235        }
3236
3237        /// Sets the value of [filter][crate::model::ListLoggingServersRequest::filter].
3238        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
3239            self.0.request.filter = v.into();
3240            self
3241        }
3242
3243        /// Sets the value of [order_by][crate::model::ListLoggingServersRequest::order_by].
3244        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
3245            self.0.request.order_by = v.into();
3246            self
3247        }
3248    }
3249
3250    #[doc(hidden)]
3251    impl gax::options::internal::RequestBuilder for ListLoggingServers {
3252        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3253            &mut self.0.options
3254        }
3255    }
3256
3257    /// The request builder for [VmwareEngine::get_logging_server][crate::client::VmwareEngine::get_logging_server] calls.
3258    ///
3259    /// # Example
3260    /// ```
3261    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetLoggingServer;
3262    /// # async fn sample() -> gax::Result<()> {
3263    ///
3264    /// let builder = prepare_request_builder();
3265    /// let response = builder.send().await?;
3266    /// # Ok(()) }
3267    ///
3268    /// fn prepare_request_builder() -> GetLoggingServer {
3269    ///   # panic!();
3270    ///   // ... details omitted ...
3271    /// }
3272    /// ```
3273    #[derive(Clone, Debug)]
3274    pub struct GetLoggingServer(RequestBuilder<crate::model::GetLoggingServerRequest>);
3275
3276    impl GetLoggingServer {
3277        pub(crate) fn new(
3278            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3279        ) -> Self {
3280            Self(RequestBuilder::new(stub))
3281        }
3282
3283        /// Sets the full request, replacing any prior values.
3284        pub fn with_request<V: Into<crate::model::GetLoggingServerRequest>>(
3285            mut self,
3286            v: V,
3287        ) -> Self {
3288            self.0.request = v.into();
3289            self
3290        }
3291
3292        /// Sets all the options, replacing any prior values.
3293        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3294            self.0.options = v.into();
3295            self
3296        }
3297
3298        /// Sends the request.
3299        pub async fn send(self) -> Result<crate::model::LoggingServer> {
3300            (*self.0.stub)
3301                .get_logging_server(self.0.request, self.0.options)
3302                .await
3303                .map(gax::response::Response::into_body)
3304        }
3305
3306        /// Sets the value of [name][crate::model::GetLoggingServerRequest::name].
3307        ///
3308        /// This is a **required** field for requests.
3309        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
3310            self.0.request.name = v.into();
3311            self
3312        }
3313    }
3314
3315    #[doc(hidden)]
3316    impl gax::options::internal::RequestBuilder for GetLoggingServer {
3317        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3318            &mut self.0.options
3319        }
3320    }
3321
3322    /// The request builder for [VmwareEngine::create_logging_server][crate::client::VmwareEngine::create_logging_server] calls.
3323    ///
3324    /// # Example
3325    /// ```
3326    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateLoggingServer;
3327    /// # async fn sample() -> gax::Result<()> {
3328    /// use lro::Poller;
3329    ///
3330    /// let builder = prepare_request_builder();
3331    /// let response = builder.poller().until_done().await?;
3332    /// # Ok(()) }
3333    ///
3334    /// fn prepare_request_builder() -> CreateLoggingServer {
3335    ///   # panic!();
3336    ///   // ... details omitted ...
3337    /// }
3338    /// ```
3339    #[derive(Clone, Debug)]
3340    pub struct CreateLoggingServer(RequestBuilder<crate::model::CreateLoggingServerRequest>);
3341
3342    impl CreateLoggingServer {
3343        pub(crate) fn new(
3344            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3345        ) -> Self {
3346            Self(RequestBuilder::new(stub))
3347        }
3348
3349        /// Sets the full request, replacing any prior values.
3350        pub fn with_request<V: Into<crate::model::CreateLoggingServerRequest>>(
3351            mut self,
3352            v: V,
3353        ) -> Self {
3354            self.0.request = v.into();
3355            self
3356        }
3357
3358        /// Sets all the options, replacing any prior values.
3359        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3360            self.0.options = v.into();
3361            self
3362        }
3363
3364        /// Sends the request.
3365        ///
3366        /// # Long running operations
3367        ///
3368        /// This starts, but does not poll, a longrunning operation. More information
3369        /// on [create_logging_server][crate::client::VmwareEngine::create_logging_server].
3370        pub async fn send(self) -> Result<longrunning::model::Operation> {
3371            (*self.0.stub)
3372                .create_logging_server(self.0.request, self.0.options)
3373                .await
3374                .map(gax::response::Response::into_body)
3375        }
3376
3377        /// Creates a [Poller][lro::Poller] to work with `create_logging_server`.
3378        pub fn poller(
3379            self,
3380        ) -> impl lro::Poller<crate::model::LoggingServer, crate::model::OperationMetadata>
3381        {
3382            type Operation = lro::internal::Operation<
3383                crate::model::LoggingServer,
3384                crate::model::OperationMetadata,
3385            >;
3386            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
3387            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
3388
3389            let stub = self.0.stub.clone();
3390            let mut options = self.0.options.clone();
3391            options.set_retry_policy(gax::retry_policy::NeverRetry);
3392            let query = move |name| {
3393                let stub = stub.clone();
3394                let options = options.clone();
3395                async {
3396                    let op = GetOperation::new(stub)
3397                        .set_name(name)
3398                        .with_options(options)
3399                        .send()
3400                        .await?;
3401                    Ok(Operation::new(op))
3402                }
3403            };
3404
3405            let start = move || async {
3406                let op = self.send().await?;
3407                Ok(Operation::new(op))
3408            };
3409
3410            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
3411        }
3412
3413        /// Sets the value of [parent][crate::model::CreateLoggingServerRequest::parent].
3414        ///
3415        /// This is a **required** field for requests.
3416        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
3417            self.0.request.parent = v.into();
3418            self
3419        }
3420
3421        /// Sets the value of [logging_server][crate::model::CreateLoggingServerRequest::logging_server].
3422        ///
3423        /// This is a **required** field for requests.
3424        pub fn set_logging_server<T>(mut self, v: T) -> Self
3425        where
3426            T: std::convert::Into<crate::model::LoggingServer>,
3427        {
3428            self.0.request.logging_server = std::option::Option::Some(v.into());
3429            self
3430        }
3431
3432        /// Sets or clears the value of [logging_server][crate::model::CreateLoggingServerRequest::logging_server].
3433        ///
3434        /// This is a **required** field for requests.
3435        pub fn set_or_clear_logging_server<T>(mut self, v: std::option::Option<T>) -> Self
3436        where
3437            T: std::convert::Into<crate::model::LoggingServer>,
3438        {
3439            self.0.request.logging_server = v.map(|x| x.into());
3440            self
3441        }
3442
3443        /// Sets the value of [logging_server_id][crate::model::CreateLoggingServerRequest::logging_server_id].
3444        ///
3445        /// This is a **required** field for requests.
3446        pub fn set_logging_server_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
3447            self.0.request.logging_server_id = v.into();
3448            self
3449        }
3450
3451        /// Sets the value of [request_id][crate::model::CreateLoggingServerRequest::request_id].
3452        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
3453            self.0.request.request_id = v.into();
3454            self
3455        }
3456    }
3457
3458    #[doc(hidden)]
3459    impl gax::options::internal::RequestBuilder for CreateLoggingServer {
3460        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3461            &mut self.0.options
3462        }
3463    }
3464
3465    /// The request builder for [VmwareEngine::update_logging_server][crate::client::VmwareEngine::update_logging_server] calls.
3466    ///
3467    /// # Example
3468    /// ```
3469    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateLoggingServer;
3470    /// # async fn sample() -> gax::Result<()> {
3471    /// use lro::Poller;
3472    ///
3473    /// let builder = prepare_request_builder();
3474    /// let response = builder.poller().until_done().await?;
3475    /// # Ok(()) }
3476    ///
3477    /// fn prepare_request_builder() -> UpdateLoggingServer {
3478    ///   # panic!();
3479    ///   // ... details omitted ...
3480    /// }
3481    /// ```
3482    #[derive(Clone, Debug)]
3483    pub struct UpdateLoggingServer(RequestBuilder<crate::model::UpdateLoggingServerRequest>);
3484
3485    impl UpdateLoggingServer {
3486        pub(crate) fn new(
3487            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3488        ) -> Self {
3489            Self(RequestBuilder::new(stub))
3490        }
3491
3492        /// Sets the full request, replacing any prior values.
3493        pub fn with_request<V: Into<crate::model::UpdateLoggingServerRequest>>(
3494            mut self,
3495            v: V,
3496        ) -> Self {
3497            self.0.request = v.into();
3498            self
3499        }
3500
3501        /// Sets all the options, replacing any prior values.
3502        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3503            self.0.options = v.into();
3504            self
3505        }
3506
3507        /// Sends the request.
3508        ///
3509        /// # Long running operations
3510        ///
3511        /// This starts, but does not poll, a longrunning operation. More information
3512        /// on [update_logging_server][crate::client::VmwareEngine::update_logging_server].
3513        pub async fn send(self) -> Result<longrunning::model::Operation> {
3514            (*self.0.stub)
3515                .update_logging_server(self.0.request, self.0.options)
3516                .await
3517                .map(gax::response::Response::into_body)
3518        }
3519
3520        /// Creates a [Poller][lro::Poller] to work with `update_logging_server`.
3521        pub fn poller(
3522            self,
3523        ) -> impl lro::Poller<crate::model::LoggingServer, crate::model::OperationMetadata>
3524        {
3525            type Operation = lro::internal::Operation<
3526                crate::model::LoggingServer,
3527                crate::model::OperationMetadata,
3528            >;
3529            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
3530            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
3531
3532            let stub = self.0.stub.clone();
3533            let mut options = self.0.options.clone();
3534            options.set_retry_policy(gax::retry_policy::NeverRetry);
3535            let query = move |name| {
3536                let stub = stub.clone();
3537                let options = options.clone();
3538                async {
3539                    let op = GetOperation::new(stub)
3540                        .set_name(name)
3541                        .with_options(options)
3542                        .send()
3543                        .await?;
3544                    Ok(Operation::new(op))
3545                }
3546            };
3547
3548            let start = move || async {
3549                let op = self.send().await?;
3550                Ok(Operation::new(op))
3551            };
3552
3553            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
3554        }
3555
3556        /// Sets the value of [update_mask][crate::model::UpdateLoggingServerRequest::update_mask].
3557        ///
3558        /// This is a **required** field for requests.
3559        pub fn set_update_mask<T>(mut self, v: T) -> Self
3560        where
3561            T: std::convert::Into<wkt::FieldMask>,
3562        {
3563            self.0.request.update_mask = std::option::Option::Some(v.into());
3564            self
3565        }
3566
3567        /// Sets or clears the value of [update_mask][crate::model::UpdateLoggingServerRequest::update_mask].
3568        ///
3569        /// This is a **required** field for requests.
3570        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
3571        where
3572            T: std::convert::Into<wkt::FieldMask>,
3573        {
3574            self.0.request.update_mask = v.map(|x| x.into());
3575            self
3576        }
3577
3578        /// Sets the value of [logging_server][crate::model::UpdateLoggingServerRequest::logging_server].
3579        ///
3580        /// This is a **required** field for requests.
3581        pub fn set_logging_server<T>(mut self, v: T) -> Self
3582        where
3583            T: std::convert::Into<crate::model::LoggingServer>,
3584        {
3585            self.0.request.logging_server = std::option::Option::Some(v.into());
3586            self
3587        }
3588
3589        /// Sets or clears the value of [logging_server][crate::model::UpdateLoggingServerRequest::logging_server].
3590        ///
3591        /// This is a **required** field for requests.
3592        pub fn set_or_clear_logging_server<T>(mut self, v: std::option::Option<T>) -> Self
3593        where
3594            T: std::convert::Into<crate::model::LoggingServer>,
3595        {
3596            self.0.request.logging_server = v.map(|x| x.into());
3597            self
3598        }
3599
3600        /// Sets the value of [request_id][crate::model::UpdateLoggingServerRequest::request_id].
3601        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
3602            self.0.request.request_id = v.into();
3603            self
3604        }
3605    }
3606
3607    #[doc(hidden)]
3608    impl gax::options::internal::RequestBuilder for UpdateLoggingServer {
3609        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3610            &mut self.0.options
3611        }
3612    }
3613
3614    /// The request builder for [VmwareEngine::delete_logging_server][crate::client::VmwareEngine::delete_logging_server] calls.
3615    ///
3616    /// # Example
3617    /// ```
3618    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteLoggingServer;
3619    /// # async fn sample() -> gax::Result<()> {
3620    /// use lro::Poller;
3621    ///
3622    /// let builder = prepare_request_builder();
3623    /// let response = builder.poller().until_done().await?;
3624    /// # Ok(()) }
3625    ///
3626    /// fn prepare_request_builder() -> DeleteLoggingServer {
3627    ///   # panic!();
3628    ///   // ... details omitted ...
3629    /// }
3630    /// ```
3631    #[derive(Clone, Debug)]
3632    pub struct DeleteLoggingServer(RequestBuilder<crate::model::DeleteLoggingServerRequest>);
3633
3634    impl DeleteLoggingServer {
3635        pub(crate) fn new(
3636            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3637        ) -> Self {
3638            Self(RequestBuilder::new(stub))
3639        }
3640
3641        /// Sets the full request, replacing any prior values.
3642        pub fn with_request<V: Into<crate::model::DeleteLoggingServerRequest>>(
3643            mut self,
3644            v: V,
3645        ) -> Self {
3646            self.0.request = v.into();
3647            self
3648        }
3649
3650        /// Sets all the options, replacing any prior values.
3651        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3652            self.0.options = v.into();
3653            self
3654        }
3655
3656        /// Sends the request.
3657        ///
3658        /// # Long running operations
3659        ///
3660        /// This starts, but does not poll, a longrunning operation. More information
3661        /// on [delete_logging_server][crate::client::VmwareEngine::delete_logging_server].
3662        pub async fn send(self) -> Result<longrunning::model::Operation> {
3663            (*self.0.stub)
3664                .delete_logging_server(self.0.request, self.0.options)
3665                .await
3666                .map(gax::response::Response::into_body)
3667        }
3668
3669        /// Creates a [Poller][lro::Poller] to work with `delete_logging_server`.
3670        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
3671            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
3672            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
3673            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
3674
3675            let stub = self.0.stub.clone();
3676            let mut options = self.0.options.clone();
3677            options.set_retry_policy(gax::retry_policy::NeverRetry);
3678            let query = move |name| {
3679                let stub = stub.clone();
3680                let options = options.clone();
3681                async {
3682                    let op = GetOperation::new(stub)
3683                        .set_name(name)
3684                        .with_options(options)
3685                        .send()
3686                        .await?;
3687                    Ok(Operation::new(op))
3688                }
3689            };
3690
3691            let start = move || async {
3692                let op = self.send().await?;
3693                Ok(Operation::new(op))
3694            };
3695
3696            lro::internal::new_unit_response_poller(
3697                polling_error_policy,
3698                polling_backoff_policy,
3699                start,
3700                query,
3701            )
3702        }
3703
3704        /// Sets the value of [name][crate::model::DeleteLoggingServerRequest::name].
3705        ///
3706        /// This is a **required** field for requests.
3707        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
3708            self.0.request.name = v.into();
3709            self
3710        }
3711
3712        /// Sets the value of [request_id][crate::model::DeleteLoggingServerRequest::request_id].
3713        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
3714            self.0.request.request_id = v.into();
3715            self
3716        }
3717    }
3718
3719    #[doc(hidden)]
3720    impl gax::options::internal::RequestBuilder for DeleteLoggingServer {
3721        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3722            &mut self.0.options
3723        }
3724    }
3725
3726    /// The request builder for [VmwareEngine::list_node_types][crate::client::VmwareEngine::list_node_types] calls.
3727    ///
3728    /// # Example
3729    /// ```
3730    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListNodeTypes;
3731    /// # async fn sample() -> gax::Result<()> {
3732    /// use gax::paginator::ItemPaginator;
3733    ///
3734    /// let builder = prepare_request_builder();
3735    /// let mut items = builder.by_item();
3736    /// while let Some(result) = items.next().await {
3737    ///   let item = result?;
3738    /// }
3739    /// # Ok(()) }
3740    ///
3741    /// fn prepare_request_builder() -> ListNodeTypes {
3742    ///   # panic!();
3743    ///   // ... details omitted ...
3744    /// }
3745    /// ```
3746    #[derive(Clone, Debug)]
3747    pub struct ListNodeTypes(RequestBuilder<crate::model::ListNodeTypesRequest>);
3748
3749    impl ListNodeTypes {
3750        pub(crate) fn new(
3751            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3752        ) -> Self {
3753            Self(RequestBuilder::new(stub))
3754        }
3755
3756        /// Sets the full request, replacing any prior values.
3757        pub fn with_request<V: Into<crate::model::ListNodeTypesRequest>>(mut self, v: V) -> Self {
3758            self.0.request = v.into();
3759            self
3760        }
3761
3762        /// Sets all the options, replacing any prior values.
3763        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3764            self.0.options = v.into();
3765            self
3766        }
3767
3768        /// Sends the request.
3769        pub async fn send(self) -> Result<crate::model::ListNodeTypesResponse> {
3770            (*self.0.stub)
3771                .list_node_types(self.0.request, self.0.options)
3772                .await
3773                .map(gax::response::Response::into_body)
3774        }
3775
3776        /// Streams each page in the collection.
3777        pub fn by_page(
3778            self,
3779        ) -> impl gax::paginator::Paginator<crate::model::ListNodeTypesResponse, gax::error::Error>
3780        {
3781            use std::clone::Clone;
3782            let token = self.0.request.page_token.clone();
3783            let execute = move |token: String| {
3784                let mut builder = self.clone();
3785                builder.0.request = builder.0.request.set_page_token(token);
3786                builder.send()
3787            };
3788            gax::paginator::internal::new_paginator(token, execute)
3789        }
3790
3791        /// Streams each item in the collection.
3792        pub fn by_item(
3793            self,
3794        ) -> impl gax::paginator::ItemPaginator<crate::model::ListNodeTypesResponse, gax::error::Error>
3795        {
3796            use gax::paginator::Paginator;
3797            self.by_page().items()
3798        }
3799
3800        /// Sets the value of [parent][crate::model::ListNodeTypesRequest::parent].
3801        ///
3802        /// This is a **required** field for requests.
3803        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
3804            self.0.request.parent = v.into();
3805            self
3806        }
3807
3808        /// Sets the value of [page_size][crate::model::ListNodeTypesRequest::page_size].
3809        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
3810            self.0.request.page_size = v.into();
3811            self
3812        }
3813
3814        /// Sets the value of [page_token][crate::model::ListNodeTypesRequest::page_token].
3815        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
3816            self.0.request.page_token = v.into();
3817            self
3818        }
3819
3820        /// Sets the value of [filter][crate::model::ListNodeTypesRequest::filter].
3821        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
3822            self.0.request.filter = v.into();
3823            self
3824        }
3825    }
3826
3827    #[doc(hidden)]
3828    impl gax::options::internal::RequestBuilder for ListNodeTypes {
3829        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3830            &mut self.0.options
3831        }
3832    }
3833
3834    /// The request builder for [VmwareEngine::get_node_type][crate::client::VmwareEngine::get_node_type] calls.
3835    ///
3836    /// # Example
3837    /// ```
3838    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetNodeType;
3839    /// # async fn sample() -> gax::Result<()> {
3840    ///
3841    /// let builder = prepare_request_builder();
3842    /// let response = builder.send().await?;
3843    /// # Ok(()) }
3844    ///
3845    /// fn prepare_request_builder() -> GetNodeType {
3846    ///   # panic!();
3847    ///   // ... details omitted ...
3848    /// }
3849    /// ```
3850    #[derive(Clone, Debug)]
3851    pub struct GetNodeType(RequestBuilder<crate::model::GetNodeTypeRequest>);
3852
3853    impl GetNodeType {
3854        pub(crate) fn new(
3855            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3856        ) -> Self {
3857            Self(RequestBuilder::new(stub))
3858        }
3859
3860        /// Sets the full request, replacing any prior values.
3861        pub fn with_request<V: Into<crate::model::GetNodeTypeRequest>>(mut self, v: V) -> Self {
3862            self.0.request = v.into();
3863            self
3864        }
3865
3866        /// Sets all the options, replacing any prior values.
3867        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3868            self.0.options = v.into();
3869            self
3870        }
3871
3872        /// Sends the request.
3873        pub async fn send(self) -> Result<crate::model::NodeType> {
3874            (*self.0.stub)
3875                .get_node_type(self.0.request, self.0.options)
3876                .await
3877                .map(gax::response::Response::into_body)
3878        }
3879
3880        /// Sets the value of [name][crate::model::GetNodeTypeRequest::name].
3881        ///
3882        /// This is a **required** field for requests.
3883        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
3884            self.0.request.name = v.into();
3885            self
3886        }
3887    }
3888
3889    #[doc(hidden)]
3890    impl gax::options::internal::RequestBuilder for GetNodeType {
3891        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3892            &mut self.0.options
3893        }
3894    }
3895
3896    /// The request builder for [VmwareEngine::show_nsx_credentials][crate::client::VmwareEngine::show_nsx_credentials] calls.
3897    ///
3898    /// # Example
3899    /// ```
3900    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ShowNsxCredentials;
3901    /// # async fn sample() -> gax::Result<()> {
3902    ///
3903    /// let builder = prepare_request_builder();
3904    /// let response = builder.send().await?;
3905    /// # Ok(()) }
3906    ///
3907    /// fn prepare_request_builder() -> ShowNsxCredentials {
3908    ///   # panic!();
3909    ///   // ... details omitted ...
3910    /// }
3911    /// ```
3912    #[derive(Clone, Debug)]
3913    pub struct ShowNsxCredentials(RequestBuilder<crate::model::ShowNsxCredentialsRequest>);
3914
3915    impl ShowNsxCredentials {
3916        pub(crate) fn new(
3917            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3918        ) -> Self {
3919            Self(RequestBuilder::new(stub))
3920        }
3921
3922        /// Sets the full request, replacing any prior values.
3923        pub fn with_request<V: Into<crate::model::ShowNsxCredentialsRequest>>(
3924            mut self,
3925            v: V,
3926        ) -> Self {
3927            self.0.request = v.into();
3928            self
3929        }
3930
3931        /// Sets all the options, replacing any prior values.
3932        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3933            self.0.options = v.into();
3934            self
3935        }
3936
3937        /// Sends the request.
3938        pub async fn send(self) -> Result<crate::model::Credentials> {
3939            (*self.0.stub)
3940                .show_nsx_credentials(self.0.request, self.0.options)
3941                .await
3942                .map(gax::response::Response::into_body)
3943        }
3944
3945        /// Sets the value of [private_cloud][crate::model::ShowNsxCredentialsRequest::private_cloud].
3946        ///
3947        /// This is a **required** field for requests.
3948        pub fn set_private_cloud<T: Into<std::string::String>>(mut self, v: T) -> Self {
3949            self.0.request.private_cloud = v.into();
3950            self
3951        }
3952    }
3953
3954    #[doc(hidden)]
3955    impl gax::options::internal::RequestBuilder for ShowNsxCredentials {
3956        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
3957            &mut self.0.options
3958        }
3959    }
3960
3961    /// The request builder for [VmwareEngine::show_vcenter_credentials][crate::client::VmwareEngine::show_vcenter_credentials] calls.
3962    ///
3963    /// # Example
3964    /// ```
3965    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ShowVcenterCredentials;
3966    /// # async fn sample() -> gax::Result<()> {
3967    ///
3968    /// let builder = prepare_request_builder();
3969    /// let response = builder.send().await?;
3970    /// # Ok(()) }
3971    ///
3972    /// fn prepare_request_builder() -> ShowVcenterCredentials {
3973    ///   # panic!();
3974    ///   // ... details omitted ...
3975    /// }
3976    /// ```
3977    #[derive(Clone, Debug)]
3978    pub struct ShowVcenterCredentials(RequestBuilder<crate::model::ShowVcenterCredentialsRequest>);
3979
3980    impl ShowVcenterCredentials {
3981        pub(crate) fn new(
3982            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
3983        ) -> Self {
3984            Self(RequestBuilder::new(stub))
3985        }
3986
3987        /// Sets the full request, replacing any prior values.
3988        pub fn with_request<V: Into<crate::model::ShowVcenterCredentialsRequest>>(
3989            mut self,
3990            v: V,
3991        ) -> Self {
3992            self.0.request = v.into();
3993            self
3994        }
3995
3996        /// Sets all the options, replacing any prior values.
3997        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
3998            self.0.options = v.into();
3999            self
4000        }
4001
4002        /// Sends the request.
4003        pub async fn send(self) -> Result<crate::model::Credentials> {
4004            (*self.0.stub)
4005                .show_vcenter_credentials(self.0.request, self.0.options)
4006                .await
4007                .map(gax::response::Response::into_body)
4008        }
4009
4010        /// Sets the value of [private_cloud][crate::model::ShowVcenterCredentialsRequest::private_cloud].
4011        ///
4012        /// This is a **required** field for requests.
4013        pub fn set_private_cloud<T: Into<std::string::String>>(mut self, v: T) -> Self {
4014            self.0.request.private_cloud = v.into();
4015            self
4016        }
4017
4018        /// Sets the value of [username][crate::model::ShowVcenterCredentialsRequest::username].
4019        pub fn set_username<T: Into<std::string::String>>(mut self, v: T) -> Self {
4020            self.0.request.username = v.into();
4021            self
4022        }
4023    }
4024
4025    #[doc(hidden)]
4026    impl gax::options::internal::RequestBuilder for ShowVcenterCredentials {
4027        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4028            &mut self.0.options
4029        }
4030    }
4031
4032    /// The request builder for [VmwareEngine::reset_nsx_credentials][crate::client::VmwareEngine::reset_nsx_credentials] calls.
4033    ///
4034    /// # Example
4035    /// ```
4036    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ResetNsxCredentials;
4037    /// # async fn sample() -> gax::Result<()> {
4038    /// use lro::Poller;
4039    ///
4040    /// let builder = prepare_request_builder();
4041    /// let response = builder.poller().until_done().await?;
4042    /// # Ok(()) }
4043    ///
4044    /// fn prepare_request_builder() -> ResetNsxCredentials {
4045    ///   # panic!();
4046    ///   // ... details omitted ...
4047    /// }
4048    /// ```
4049    #[derive(Clone, Debug)]
4050    pub struct ResetNsxCredentials(RequestBuilder<crate::model::ResetNsxCredentialsRequest>);
4051
4052    impl ResetNsxCredentials {
4053        pub(crate) fn new(
4054            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4055        ) -> Self {
4056            Self(RequestBuilder::new(stub))
4057        }
4058
4059        /// Sets the full request, replacing any prior values.
4060        pub fn with_request<V: Into<crate::model::ResetNsxCredentialsRequest>>(
4061            mut self,
4062            v: V,
4063        ) -> Self {
4064            self.0.request = v.into();
4065            self
4066        }
4067
4068        /// Sets all the options, replacing any prior values.
4069        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4070            self.0.options = v.into();
4071            self
4072        }
4073
4074        /// Sends the request.
4075        ///
4076        /// # Long running operations
4077        ///
4078        /// This starts, but does not poll, a longrunning operation. More information
4079        /// on [reset_nsx_credentials][crate::client::VmwareEngine::reset_nsx_credentials].
4080        pub async fn send(self) -> Result<longrunning::model::Operation> {
4081            (*self.0.stub)
4082                .reset_nsx_credentials(self.0.request, self.0.options)
4083                .await
4084                .map(gax::response::Response::into_body)
4085        }
4086
4087        /// Creates a [Poller][lro::Poller] to work with `reset_nsx_credentials`.
4088        pub fn poller(
4089            self,
4090        ) -> impl lro::Poller<crate::model::PrivateCloud, crate::model::OperationMetadata> {
4091            type Operation = lro::internal::Operation<
4092                crate::model::PrivateCloud,
4093                crate::model::OperationMetadata,
4094            >;
4095            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
4096            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
4097
4098            let stub = self.0.stub.clone();
4099            let mut options = self.0.options.clone();
4100            options.set_retry_policy(gax::retry_policy::NeverRetry);
4101            let query = move |name| {
4102                let stub = stub.clone();
4103                let options = options.clone();
4104                async {
4105                    let op = GetOperation::new(stub)
4106                        .set_name(name)
4107                        .with_options(options)
4108                        .send()
4109                        .await?;
4110                    Ok(Operation::new(op))
4111                }
4112            };
4113
4114            let start = move || async {
4115                let op = self.send().await?;
4116                Ok(Operation::new(op))
4117            };
4118
4119            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
4120        }
4121
4122        /// Sets the value of [private_cloud][crate::model::ResetNsxCredentialsRequest::private_cloud].
4123        ///
4124        /// This is a **required** field for requests.
4125        pub fn set_private_cloud<T: Into<std::string::String>>(mut self, v: T) -> Self {
4126            self.0.request.private_cloud = v.into();
4127            self
4128        }
4129
4130        /// Sets the value of [request_id][crate::model::ResetNsxCredentialsRequest::request_id].
4131        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
4132            self.0.request.request_id = v.into();
4133            self
4134        }
4135    }
4136
4137    #[doc(hidden)]
4138    impl gax::options::internal::RequestBuilder for ResetNsxCredentials {
4139        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4140            &mut self.0.options
4141        }
4142    }
4143
4144    /// The request builder for [VmwareEngine::reset_vcenter_credentials][crate::client::VmwareEngine::reset_vcenter_credentials] calls.
4145    ///
4146    /// # Example
4147    /// ```
4148    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ResetVcenterCredentials;
4149    /// # async fn sample() -> gax::Result<()> {
4150    /// use lro::Poller;
4151    ///
4152    /// let builder = prepare_request_builder();
4153    /// let response = builder.poller().until_done().await?;
4154    /// # Ok(()) }
4155    ///
4156    /// fn prepare_request_builder() -> ResetVcenterCredentials {
4157    ///   # panic!();
4158    ///   // ... details omitted ...
4159    /// }
4160    /// ```
4161    #[derive(Clone, Debug)]
4162    pub struct ResetVcenterCredentials(
4163        RequestBuilder<crate::model::ResetVcenterCredentialsRequest>,
4164    );
4165
4166    impl ResetVcenterCredentials {
4167        pub(crate) fn new(
4168            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4169        ) -> Self {
4170            Self(RequestBuilder::new(stub))
4171        }
4172
4173        /// Sets the full request, replacing any prior values.
4174        pub fn with_request<V: Into<crate::model::ResetVcenterCredentialsRequest>>(
4175            mut self,
4176            v: V,
4177        ) -> Self {
4178            self.0.request = v.into();
4179            self
4180        }
4181
4182        /// Sets all the options, replacing any prior values.
4183        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4184            self.0.options = v.into();
4185            self
4186        }
4187
4188        /// Sends the request.
4189        ///
4190        /// # Long running operations
4191        ///
4192        /// This starts, but does not poll, a longrunning operation. More information
4193        /// on [reset_vcenter_credentials][crate::client::VmwareEngine::reset_vcenter_credentials].
4194        pub async fn send(self) -> Result<longrunning::model::Operation> {
4195            (*self.0.stub)
4196                .reset_vcenter_credentials(self.0.request, self.0.options)
4197                .await
4198                .map(gax::response::Response::into_body)
4199        }
4200
4201        /// Creates a [Poller][lro::Poller] to work with `reset_vcenter_credentials`.
4202        pub fn poller(
4203            self,
4204        ) -> impl lro::Poller<crate::model::PrivateCloud, crate::model::OperationMetadata> {
4205            type Operation = lro::internal::Operation<
4206                crate::model::PrivateCloud,
4207                crate::model::OperationMetadata,
4208            >;
4209            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
4210            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
4211
4212            let stub = self.0.stub.clone();
4213            let mut options = self.0.options.clone();
4214            options.set_retry_policy(gax::retry_policy::NeverRetry);
4215            let query = move |name| {
4216                let stub = stub.clone();
4217                let options = options.clone();
4218                async {
4219                    let op = GetOperation::new(stub)
4220                        .set_name(name)
4221                        .with_options(options)
4222                        .send()
4223                        .await?;
4224                    Ok(Operation::new(op))
4225                }
4226            };
4227
4228            let start = move || async {
4229                let op = self.send().await?;
4230                Ok(Operation::new(op))
4231            };
4232
4233            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
4234        }
4235
4236        /// Sets the value of [private_cloud][crate::model::ResetVcenterCredentialsRequest::private_cloud].
4237        ///
4238        /// This is a **required** field for requests.
4239        pub fn set_private_cloud<T: Into<std::string::String>>(mut self, v: T) -> Self {
4240            self.0.request.private_cloud = v.into();
4241            self
4242        }
4243
4244        /// Sets the value of [request_id][crate::model::ResetVcenterCredentialsRequest::request_id].
4245        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
4246            self.0.request.request_id = v.into();
4247            self
4248        }
4249
4250        /// Sets the value of [username][crate::model::ResetVcenterCredentialsRequest::username].
4251        pub fn set_username<T: Into<std::string::String>>(mut self, v: T) -> Self {
4252            self.0.request.username = v.into();
4253            self
4254        }
4255    }
4256
4257    #[doc(hidden)]
4258    impl gax::options::internal::RequestBuilder for ResetVcenterCredentials {
4259        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4260            &mut self.0.options
4261        }
4262    }
4263
4264    /// The request builder for [VmwareEngine::get_dns_forwarding][crate::client::VmwareEngine::get_dns_forwarding] calls.
4265    ///
4266    /// # Example
4267    /// ```
4268    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetDnsForwarding;
4269    /// # async fn sample() -> gax::Result<()> {
4270    ///
4271    /// let builder = prepare_request_builder();
4272    /// let response = builder.send().await?;
4273    /// # Ok(()) }
4274    ///
4275    /// fn prepare_request_builder() -> GetDnsForwarding {
4276    ///   # panic!();
4277    ///   // ... details omitted ...
4278    /// }
4279    /// ```
4280    #[derive(Clone, Debug)]
4281    pub struct GetDnsForwarding(RequestBuilder<crate::model::GetDnsForwardingRequest>);
4282
4283    impl GetDnsForwarding {
4284        pub(crate) fn new(
4285            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4286        ) -> Self {
4287            Self(RequestBuilder::new(stub))
4288        }
4289
4290        /// Sets the full request, replacing any prior values.
4291        pub fn with_request<V: Into<crate::model::GetDnsForwardingRequest>>(
4292            mut self,
4293            v: V,
4294        ) -> Self {
4295            self.0.request = v.into();
4296            self
4297        }
4298
4299        /// Sets all the options, replacing any prior values.
4300        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4301            self.0.options = v.into();
4302            self
4303        }
4304
4305        /// Sends the request.
4306        pub async fn send(self) -> Result<crate::model::DnsForwarding> {
4307            (*self.0.stub)
4308                .get_dns_forwarding(self.0.request, self.0.options)
4309                .await
4310                .map(gax::response::Response::into_body)
4311        }
4312
4313        /// Sets the value of [name][crate::model::GetDnsForwardingRequest::name].
4314        ///
4315        /// This is a **required** field for requests.
4316        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
4317            self.0.request.name = v.into();
4318            self
4319        }
4320    }
4321
4322    #[doc(hidden)]
4323    impl gax::options::internal::RequestBuilder for GetDnsForwarding {
4324        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4325            &mut self.0.options
4326        }
4327    }
4328
4329    /// The request builder for [VmwareEngine::update_dns_forwarding][crate::client::VmwareEngine::update_dns_forwarding] calls.
4330    ///
4331    /// # Example
4332    /// ```
4333    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateDnsForwarding;
4334    /// # async fn sample() -> gax::Result<()> {
4335    /// use lro::Poller;
4336    ///
4337    /// let builder = prepare_request_builder();
4338    /// let response = builder.poller().until_done().await?;
4339    /// # Ok(()) }
4340    ///
4341    /// fn prepare_request_builder() -> UpdateDnsForwarding {
4342    ///   # panic!();
4343    ///   // ... details omitted ...
4344    /// }
4345    /// ```
4346    #[derive(Clone, Debug)]
4347    pub struct UpdateDnsForwarding(RequestBuilder<crate::model::UpdateDnsForwardingRequest>);
4348
4349    impl UpdateDnsForwarding {
4350        pub(crate) fn new(
4351            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4352        ) -> Self {
4353            Self(RequestBuilder::new(stub))
4354        }
4355
4356        /// Sets the full request, replacing any prior values.
4357        pub fn with_request<V: Into<crate::model::UpdateDnsForwardingRequest>>(
4358            mut self,
4359            v: V,
4360        ) -> Self {
4361            self.0.request = v.into();
4362            self
4363        }
4364
4365        /// Sets all the options, replacing any prior values.
4366        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4367            self.0.options = v.into();
4368            self
4369        }
4370
4371        /// Sends the request.
4372        ///
4373        /// # Long running operations
4374        ///
4375        /// This starts, but does not poll, a longrunning operation. More information
4376        /// on [update_dns_forwarding][crate::client::VmwareEngine::update_dns_forwarding].
4377        pub async fn send(self) -> Result<longrunning::model::Operation> {
4378            (*self.0.stub)
4379                .update_dns_forwarding(self.0.request, self.0.options)
4380                .await
4381                .map(gax::response::Response::into_body)
4382        }
4383
4384        /// Creates a [Poller][lro::Poller] to work with `update_dns_forwarding`.
4385        pub fn poller(
4386            self,
4387        ) -> impl lro::Poller<crate::model::DnsForwarding, crate::model::OperationMetadata>
4388        {
4389            type Operation = lro::internal::Operation<
4390                crate::model::DnsForwarding,
4391                crate::model::OperationMetadata,
4392            >;
4393            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
4394            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
4395
4396            let stub = self.0.stub.clone();
4397            let mut options = self.0.options.clone();
4398            options.set_retry_policy(gax::retry_policy::NeverRetry);
4399            let query = move |name| {
4400                let stub = stub.clone();
4401                let options = options.clone();
4402                async {
4403                    let op = GetOperation::new(stub)
4404                        .set_name(name)
4405                        .with_options(options)
4406                        .send()
4407                        .await?;
4408                    Ok(Operation::new(op))
4409                }
4410            };
4411
4412            let start = move || async {
4413                let op = self.send().await?;
4414                Ok(Operation::new(op))
4415            };
4416
4417            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
4418        }
4419
4420        /// Sets the value of [dns_forwarding][crate::model::UpdateDnsForwardingRequest::dns_forwarding].
4421        ///
4422        /// This is a **required** field for requests.
4423        pub fn set_dns_forwarding<T>(mut self, v: T) -> Self
4424        where
4425            T: std::convert::Into<crate::model::DnsForwarding>,
4426        {
4427            self.0.request.dns_forwarding = std::option::Option::Some(v.into());
4428            self
4429        }
4430
4431        /// Sets or clears the value of [dns_forwarding][crate::model::UpdateDnsForwardingRequest::dns_forwarding].
4432        ///
4433        /// This is a **required** field for requests.
4434        pub fn set_or_clear_dns_forwarding<T>(mut self, v: std::option::Option<T>) -> Self
4435        where
4436            T: std::convert::Into<crate::model::DnsForwarding>,
4437        {
4438            self.0.request.dns_forwarding = v.map(|x| x.into());
4439            self
4440        }
4441
4442        /// Sets the value of [update_mask][crate::model::UpdateDnsForwardingRequest::update_mask].
4443        ///
4444        /// This is a **required** field for requests.
4445        pub fn set_update_mask<T>(mut self, v: T) -> Self
4446        where
4447            T: std::convert::Into<wkt::FieldMask>,
4448        {
4449            self.0.request.update_mask = std::option::Option::Some(v.into());
4450            self
4451        }
4452
4453        /// Sets or clears the value of [update_mask][crate::model::UpdateDnsForwardingRequest::update_mask].
4454        ///
4455        /// This is a **required** field for requests.
4456        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
4457        where
4458            T: std::convert::Into<wkt::FieldMask>,
4459        {
4460            self.0.request.update_mask = v.map(|x| x.into());
4461            self
4462        }
4463
4464        /// Sets the value of [request_id][crate::model::UpdateDnsForwardingRequest::request_id].
4465        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
4466            self.0.request.request_id = v.into();
4467            self
4468        }
4469    }
4470
4471    #[doc(hidden)]
4472    impl gax::options::internal::RequestBuilder for UpdateDnsForwarding {
4473        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4474            &mut self.0.options
4475        }
4476    }
4477
4478    /// The request builder for [VmwareEngine::get_network_peering][crate::client::VmwareEngine::get_network_peering] calls.
4479    ///
4480    /// # Example
4481    /// ```
4482    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetNetworkPeering;
4483    /// # async fn sample() -> gax::Result<()> {
4484    ///
4485    /// let builder = prepare_request_builder();
4486    /// let response = builder.send().await?;
4487    /// # Ok(()) }
4488    ///
4489    /// fn prepare_request_builder() -> GetNetworkPeering {
4490    ///   # panic!();
4491    ///   // ... details omitted ...
4492    /// }
4493    /// ```
4494    #[derive(Clone, Debug)]
4495    pub struct GetNetworkPeering(RequestBuilder<crate::model::GetNetworkPeeringRequest>);
4496
4497    impl GetNetworkPeering {
4498        pub(crate) fn new(
4499            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4500        ) -> Self {
4501            Self(RequestBuilder::new(stub))
4502        }
4503
4504        /// Sets the full request, replacing any prior values.
4505        pub fn with_request<V: Into<crate::model::GetNetworkPeeringRequest>>(
4506            mut self,
4507            v: V,
4508        ) -> Self {
4509            self.0.request = v.into();
4510            self
4511        }
4512
4513        /// Sets all the options, replacing any prior values.
4514        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4515            self.0.options = v.into();
4516            self
4517        }
4518
4519        /// Sends the request.
4520        pub async fn send(self) -> Result<crate::model::NetworkPeering> {
4521            (*self.0.stub)
4522                .get_network_peering(self.0.request, self.0.options)
4523                .await
4524                .map(gax::response::Response::into_body)
4525        }
4526
4527        /// Sets the value of [name][crate::model::GetNetworkPeeringRequest::name].
4528        ///
4529        /// This is a **required** field for requests.
4530        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
4531            self.0.request.name = v.into();
4532            self
4533        }
4534    }
4535
4536    #[doc(hidden)]
4537    impl gax::options::internal::RequestBuilder for GetNetworkPeering {
4538        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4539            &mut self.0.options
4540        }
4541    }
4542
4543    /// The request builder for [VmwareEngine::list_network_peerings][crate::client::VmwareEngine::list_network_peerings] calls.
4544    ///
4545    /// # Example
4546    /// ```
4547    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListNetworkPeerings;
4548    /// # async fn sample() -> gax::Result<()> {
4549    /// use gax::paginator::ItemPaginator;
4550    ///
4551    /// let builder = prepare_request_builder();
4552    /// let mut items = builder.by_item();
4553    /// while let Some(result) = items.next().await {
4554    ///   let item = result?;
4555    /// }
4556    /// # Ok(()) }
4557    ///
4558    /// fn prepare_request_builder() -> ListNetworkPeerings {
4559    ///   # panic!();
4560    ///   // ... details omitted ...
4561    /// }
4562    /// ```
4563    #[derive(Clone, Debug)]
4564    pub struct ListNetworkPeerings(RequestBuilder<crate::model::ListNetworkPeeringsRequest>);
4565
4566    impl ListNetworkPeerings {
4567        pub(crate) fn new(
4568            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4569        ) -> Self {
4570            Self(RequestBuilder::new(stub))
4571        }
4572
4573        /// Sets the full request, replacing any prior values.
4574        pub fn with_request<V: Into<crate::model::ListNetworkPeeringsRequest>>(
4575            mut self,
4576            v: V,
4577        ) -> Self {
4578            self.0.request = v.into();
4579            self
4580        }
4581
4582        /// Sets all the options, replacing any prior values.
4583        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4584            self.0.options = v.into();
4585            self
4586        }
4587
4588        /// Sends the request.
4589        pub async fn send(self) -> Result<crate::model::ListNetworkPeeringsResponse> {
4590            (*self.0.stub)
4591                .list_network_peerings(self.0.request, self.0.options)
4592                .await
4593                .map(gax::response::Response::into_body)
4594        }
4595
4596        /// Streams each page in the collection.
4597        pub fn by_page(
4598            self,
4599        ) -> impl gax::paginator::Paginator<crate::model::ListNetworkPeeringsResponse, gax::error::Error>
4600        {
4601            use std::clone::Clone;
4602            let token = self.0.request.page_token.clone();
4603            let execute = move |token: String| {
4604                let mut builder = self.clone();
4605                builder.0.request = builder.0.request.set_page_token(token);
4606                builder.send()
4607            };
4608            gax::paginator::internal::new_paginator(token, execute)
4609        }
4610
4611        /// Streams each item in the collection.
4612        pub fn by_item(
4613            self,
4614        ) -> impl gax::paginator::ItemPaginator<
4615            crate::model::ListNetworkPeeringsResponse,
4616            gax::error::Error,
4617        > {
4618            use gax::paginator::Paginator;
4619            self.by_page().items()
4620        }
4621
4622        /// Sets the value of [parent][crate::model::ListNetworkPeeringsRequest::parent].
4623        ///
4624        /// This is a **required** field for requests.
4625        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
4626            self.0.request.parent = v.into();
4627            self
4628        }
4629
4630        /// Sets the value of [page_size][crate::model::ListNetworkPeeringsRequest::page_size].
4631        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
4632            self.0.request.page_size = v.into();
4633            self
4634        }
4635
4636        /// Sets the value of [page_token][crate::model::ListNetworkPeeringsRequest::page_token].
4637        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
4638            self.0.request.page_token = v.into();
4639            self
4640        }
4641
4642        /// Sets the value of [filter][crate::model::ListNetworkPeeringsRequest::filter].
4643        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
4644            self.0.request.filter = v.into();
4645            self
4646        }
4647
4648        /// Sets the value of [order_by][crate::model::ListNetworkPeeringsRequest::order_by].
4649        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
4650            self.0.request.order_by = v.into();
4651            self
4652        }
4653    }
4654
4655    #[doc(hidden)]
4656    impl gax::options::internal::RequestBuilder for ListNetworkPeerings {
4657        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4658            &mut self.0.options
4659        }
4660    }
4661
4662    /// The request builder for [VmwareEngine::create_network_peering][crate::client::VmwareEngine::create_network_peering] calls.
4663    ///
4664    /// # Example
4665    /// ```
4666    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateNetworkPeering;
4667    /// # async fn sample() -> gax::Result<()> {
4668    /// use lro::Poller;
4669    ///
4670    /// let builder = prepare_request_builder();
4671    /// let response = builder.poller().until_done().await?;
4672    /// # Ok(()) }
4673    ///
4674    /// fn prepare_request_builder() -> CreateNetworkPeering {
4675    ///   # panic!();
4676    ///   // ... details omitted ...
4677    /// }
4678    /// ```
4679    #[derive(Clone, Debug)]
4680    pub struct CreateNetworkPeering(RequestBuilder<crate::model::CreateNetworkPeeringRequest>);
4681
4682    impl CreateNetworkPeering {
4683        pub(crate) fn new(
4684            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4685        ) -> Self {
4686            Self(RequestBuilder::new(stub))
4687        }
4688
4689        /// Sets the full request, replacing any prior values.
4690        pub fn with_request<V: Into<crate::model::CreateNetworkPeeringRequest>>(
4691            mut self,
4692            v: V,
4693        ) -> Self {
4694            self.0.request = v.into();
4695            self
4696        }
4697
4698        /// Sets all the options, replacing any prior values.
4699        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4700            self.0.options = v.into();
4701            self
4702        }
4703
4704        /// Sends the request.
4705        ///
4706        /// # Long running operations
4707        ///
4708        /// This starts, but does not poll, a longrunning operation. More information
4709        /// on [create_network_peering][crate::client::VmwareEngine::create_network_peering].
4710        pub async fn send(self) -> Result<longrunning::model::Operation> {
4711            (*self.0.stub)
4712                .create_network_peering(self.0.request, self.0.options)
4713                .await
4714                .map(gax::response::Response::into_body)
4715        }
4716
4717        /// Creates a [Poller][lro::Poller] to work with `create_network_peering`.
4718        pub fn poller(
4719            self,
4720        ) -> impl lro::Poller<crate::model::NetworkPeering, crate::model::OperationMetadata>
4721        {
4722            type Operation = lro::internal::Operation<
4723                crate::model::NetworkPeering,
4724                crate::model::OperationMetadata,
4725            >;
4726            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
4727            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
4728
4729            let stub = self.0.stub.clone();
4730            let mut options = self.0.options.clone();
4731            options.set_retry_policy(gax::retry_policy::NeverRetry);
4732            let query = move |name| {
4733                let stub = stub.clone();
4734                let options = options.clone();
4735                async {
4736                    let op = GetOperation::new(stub)
4737                        .set_name(name)
4738                        .with_options(options)
4739                        .send()
4740                        .await?;
4741                    Ok(Operation::new(op))
4742                }
4743            };
4744
4745            let start = move || async {
4746                let op = self.send().await?;
4747                Ok(Operation::new(op))
4748            };
4749
4750            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
4751        }
4752
4753        /// Sets the value of [parent][crate::model::CreateNetworkPeeringRequest::parent].
4754        ///
4755        /// This is a **required** field for requests.
4756        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
4757            self.0.request.parent = v.into();
4758            self
4759        }
4760
4761        /// Sets the value of [network_peering_id][crate::model::CreateNetworkPeeringRequest::network_peering_id].
4762        ///
4763        /// This is a **required** field for requests.
4764        pub fn set_network_peering_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
4765            self.0.request.network_peering_id = v.into();
4766            self
4767        }
4768
4769        /// Sets the value of [network_peering][crate::model::CreateNetworkPeeringRequest::network_peering].
4770        ///
4771        /// This is a **required** field for requests.
4772        pub fn set_network_peering<T>(mut self, v: T) -> Self
4773        where
4774            T: std::convert::Into<crate::model::NetworkPeering>,
4775        {
4776            self.0.request.network_peering = std::option::Option::Some(v.into());
4777            self
4778        }
4779
4780        /// Sets or clears the value of [network_peering][crate::model::CreateNetworkPeeringRequest::network_peering].
4781        ///
4782        /// This is a **required** field for requests.
4783        pub fn set_or_clear_network_peering<T>(mut self, v: std::option::Option<T>) -> Self
4784        where
4785            T: std::convert::Into<crate::model::NetworkPeering>,
4786        {
4787            self.0.request.network_peering = v.map(|x| x.into());
4788            self
4789        }
4790
4791        /// Sets the value of [request_id][crate::model::CreateNetworkPeeringRequest::request_id].
4792        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
4793            self.0.request.request_id = v.into();
4794            self
4795        }
4796    }
4797
4798    #[doc(hidden)]
4799    impl gax::options::internal::RequestBuilder for CreateNetworkPeering {
4800        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4801            &mut self.0.options
4802        }
4803    }
4804
4805    /// The request builder for [VmwareEngine::delete_network_peering][crate::client::VmwareEngine::delete_network_peering] calls.
4806    ///
4807    /// # Example
4808    /// ```
4809    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteNetworkPeering;
4810    /// # async fn sample() -> gax::Result<()> {
4811    /// use lro::Poller;
4812    ///
4813    /// let builder = prepare_request_builder();
4814    /// let response = builder.poller().until_done().await?;
4815    /// # Ok(()) }
4816    ///
4817    /// fn prepare_request_builder() -> DeleteNetworkPeering {
4818    ///   # panic!();
4819    ///   // ... details omitted ...
4820    /// }
4821    /// ```
4822    #[derive(Clone, Debug)]
4823    pub struct DeleteNetworkPeering(RequestBuilder<crate::model::DeleteNetworkPeeringRequest>);
4824
4825    impl DeleteNetworkPeering {
4826        pub(crate) fn new(
4827            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4828        ) -> Self {
4829            Self(RequestBuilder::new(stub))
4830        }
4831
4832        /// Sets the full request, replacing any prior values.
4833        pub fn with_request<V: Into<crate::model::DeleteNetworkPeeringRequest>>(
4834            mut self,
4835            v: V,
4836        ) -> Self {
4837            self.0.request = v.into();
4838            self
4839        }
4840
4841        /// Sets all the options, replacing any prior values.
4842        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4843            self.0.options = v.into();
4844            self
4845        }
4846
4847        /// Sends the request.
4848        ///
4849        /// # Long running operations
4850        ///
4851        /// This starts, but does not poll, a longrunning operation. More information
4852        /// on [delete_network_peering][crate::client::VmwareEngine::delete_network_peering].
4853        pub async fn send(self) -> Result<longrunning::model::Operation> {
4854            (*self.0.stub)
4855                .delete_network_peering(self.0.request, self.0.options)
4856                .await
4857                .map(gax::response::Response::into_body)
4858        }
4859
4860        /// Creates a [Poller][lro::Poller] to work with `delete_network_peering`.
4861        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
4862            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
4863            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
4864            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
4865
4866            let stub = self.0.stub.clone();
4867            let mut options = self.0.options.clone();
4868            options.set_retry_policy(gax::retry_policy::NeverRetry);
4869            let query = move |name| {
4870                let stub = stub.clone();
4871                let options = options.clone();
4872                async {
4873                    let op = GetOperation::new(stub)
4874                        .set_name(name)
4875                        .with_options(options)
4876                        .send()
4877                        .await?;
4878                    Ok(Operation::new(op))
4879                }
4880            };
4881
4882            let start = move || async {
4883                let op = self.send().await?;
4884                Ok(Operation::new(op))
4885            };
4886
4887            lro::internal::new_unit_response_poller(
4888                polling_error_policy,
4889                polling_backoff_policy,
4890                start,
4891                query,
4892            )
4893        }
4894
4895        /// Sets the value of [name][crate::model::DeleteNetworkPeeringRequest::name].
4896        ///
4897        /// This is a **required** field for requests.
4898        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
4899            self.0.request.name = v.into();
4900            self
4901        }
4902
4903        /// Sets the value of [request_id][crate::model::DeleteNetworkPeeringRequest::request_id].
4904        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
4905            self.0.request.request_id = v.into();
4906            self
4907        }
4908    }
4909
4910    #[doc(hidden)]
4911    impl gax::options::internal::RequestBuilder for DeleteNetworkPeering {
4912        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
4913            &mut self.0.options
4914        }
4915    }
4916
4917    /// The request builder for [VmwareEngine::update_network_peering][crate::client::VmwareEngine::update_network_peering] calls.
4918    ///
4919    /// # Example
4920    /// ```
4921    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateNetworkPeering;
4922    /// # async fn sample() -> gax::Result<()> {
4923    /// use lro::Poller;
4924    ///
4925    /// let builder = prepare_request_builder();
4926    /// let response = builder.poller().until_done().await?;
4927    /// # Ok(()) }
4928    ///
4929    /// fn prepare_request_builder() -> UpdateNetworkPeering {
4930    ///   # panic!();
4931    ///   // ... details omitted ...
4932    /// }
4933    /// ```
4934    #[derive(Clone, Debug)]
4935    pub struct UpdateNetworkPeering(RequestBuilder<crate::model::UpdateNetworkPeeringRequest>);
4936
4937    impl UpdateNetworkPeering {
4938        pub(crate) fn new(
4939            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
4940        ) -> Self {
4941            Self(RequestBuilder::new(stub))
4942        }
4943
4944        /// Sets the full request, replacing any prior values.
4945        pub fn with_request<V: Into<crate::model::UpdateNetworkPeeringRequest>>(
4946            mut self,
4947            v: V,
4948        ) -> Self {
4949            self.0.request = v.into();
4950            self
4951        }
4952
4953        /// Sets all the options, replacing any prior values.
4954        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
4955            self.0.options = v.into();
4956            self
4957        }
4958
4959        /// Sends the request.
4960        ///
4961        /// # Long running operations
4962        ///
4963        /// This starts, but does not poll, a longrunning operation. More information
4964        /// on [update_network_peering][crate::client::VmwareEngine::update_network_peering].
4965        pub async fn send(self) -> Result<longrunning::model::Operation> {
4966            (*self.0.stub)
4967                .update_network_peering(self.0.request, self.0.options)
4968                .await
4969                .map(gax::response::Response::into_body)
4970        }
4971
4972        /// Creates a [Poller][lro::Poller] to work with `update_network_peering`.
4973        pub fn poller(
4974            self,
4975        ) -> impl lro::Poller<crate::model::NetworkPeering, crate::model::OperationMetadata>
4976        {
4977            type Operation = lro::internal::Operation<
4978                crate::model::NetworkPeering,
4979                crate::model::OperationMetadata,
4980            >;
4981            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
4982            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
4983
4984            let stub = self.0.stub.clone();
4985            let mut options = self.0.options.clone();
4986            options.set_retry_policy(gax::retry_policy::NeverRetry);
4987            let query = move |name| {
4988                let stub = stub.clone();
4989                let options = options.clone();
4990                async {
4991                    let op = GetOperation::new(stub)
4992                        .set_name(name)
4993                        .with_options(options)
4994                        .send()
4995                        .await?;
4996                    Ok(Operation::new(op))
4997                }
4998            };
4999
5000            let start = move || async {
5001                let op = self.send().await?;
5002                Ok(Operation::new(op))
5003            };
5004
5005            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
5006        }
5007
5008        /// Sets the value of [network_peering][crate::model::UpdateNetworkPeeringRequest::network_peering].
5009        ///
5010        /// This is a **required** field for requests.
5011        pub fn set_network_peering<T>(mut self, v: T) -> Self
5012        where
5013            T: std::convert::Into<crate::model::NetworkPeering>,
5014        {
5015            self.0.request.network_peering = std::option::Option::Some(v.into());
5016            self
5017        }
5018
5019        /// Sets or clears the value of [network_peering][crate::model::UpdateNetworkPeeringRequest::network_peering].
5020        ///
5021        /// This is a **required** field for requests.
5022        pub fn set_or_clear_network_peering<T>(mut self, v: std::option::Option<T>) -> Self
5023        where
5024            T: std::convert::Into<crate::model::NetworkPeering>,
5025        {
5026            self.0.request.network_peering = v.map(|x| x.into());
5027            self
5028        }
5029
5030        /// Sets the value of [update_mask][crate::model::UpdateNetworkPeeringRequest::update_mask].
5031        ///
5032        /// This is a **required** field for requests.
5033        pub fn set_update_mask<T>(mut self, v: T) -> Self
5034        where
5035            T: std::convert::Into<wkt::FieldMask>,
5036        {
5037            self.0.request.update_mask = std::option::Option::Some(v.into());
5038            self
5039        }
5040
5041        /// Sets or clears the value of [update_mask][crate::model::UpdateNetworkPeeringRequest::update_mask].
5042        ///
5043        /// This is a **required** field for requests.
5044        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
5045        where
5046            T: std::convert::Into<wkt::FieldMask>,
5047        {
5048            self.0.request.update_mask = v.map(|x| x.into());
5049            self
5050        }
5051
5052        /// Sets the value of [request_id][crate::model::UpdateNetworkPeeringRequest::request_id].
5053        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
5054            self.0.request.request_id = v.into();
5055            self
5056        }
5057    }
5058
5059    #[doc(hidden)]
5060    impl gax::options::internal::RequestBuilder for UpdateNetworkPeering {
5061        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5062            &mut self.0.options
5063        }
5064    }
5065
5066    /// The request builder for [VmwareEngine::list_peering_routes][crate::client::VmwareEngine::list_peering_routes] calls.
5067    ///
5068    /// # Example
5069    /// ```
5070    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListPeeringRoutes;
5071    /// # async fn sample() -> gax::Result<()> {
5072    /// use gax::paginator::ItemPaginator;
5073    ///
5074    /// let builder = prepare_request_builder();
5075    /// let mut items = builder.by_item();
5076    /// while let Some(result) = items.next().await {
5077    ///   let item = result?;
5078    /// }
5079    /// # Ok(()) }
5080    ///
5081    /// fn prepare_request_builder() -> ListPeeringRoutes {
5082    ///   # panic!();
5083    ///   // ... details omitted ...
5084    /// }
5085    /// ```
5086    #[derive(Clone, Debug)]
5087    pub struct ListPeeringRoutes(RequestBuilder<crate::model::ListPeeringRoutesRequest>);
5088
5089    impl ListPeeringRoutes {
5090        pub(crate) fn new(
5091            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5092        ) -> Self {
5093            Self(RequestBuilder::new(stub))
5094        }
5095
5096        /// Sets the full request, replacing any prior values.
5097        pub fn with_request<V: Into<crate::model::ListPeeringRoutesRequest>>(
5098            mut self,
5099            v: V,
5100        ) -> Self {
5101            self.0.request = v.into();
5102            self
5103        }
5104
5105        /// Sets all the options, replacing any prior values.
5106        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
5107            self.0.options = v.into();
5108            self
5109        }
5110
5111        /// Sends the request.
5112        pub async fn send(self) -> Result<crate::model::ListPeeringRoutesResponse> {
5113            (*self.0.stub)
5114                .list_peering_routes(self.0.request, self.0.options)
5115                .await
5116                .map(gax::response::Response::into_body)
5117        }
5118
5119        /// Streams each page in the collection.
5120        pub fn by_page(
5121            self,
5122        ) -> impl gax::paginator::Paginator<crate::model::ListPeeringRoutesResponse, gax::error::Error>
5123        {
5124            use std::clone::Clone;
5125            let token = self.0.request.page_token.clone();
5126            let execute = move |token: String| {
5127                let mut builder = self.clone();
5128                builder.0.request = builder.0.request.set_page_token(token);
5129                builder.send()
5130            };
5131            gax::paginator::internal::new_paginator(token, execute)
5132        }
5133
5134        /// Streams each item in the collection.
5135        pub fn by_item(
5136            self,
5137        ) -> impl gax::paginator::ItemPaginator<crate::model::ListPeeringRoutesResponse, gax::error::Error>
5138        {
5139            use gax::paginator::Paginator;
5140            self.by_page().items()
5141        }
5142
5143        /// Sets the value of [parent][crate::model::ListPeeringRoutesRequest::parent].
5144        ///
5145        /// This is a **required** field for requests.
5146        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
5147            self.0.request.parent = v.into();
5148            self
5149        }
5150
5151        /// Sets the value of [page_size][crate::model::ListPeeringRoutesRequest::page_size].
5152        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
5153            self.0.request.page_size = v.into();
5154            self
5155        }
5156
5157        /// Sets the value of [page_token][crate::model::ListPeeringRoutesRequest::page_token].
5158        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
5159            self.0.request.page_token = v.into();
5160            self
5161        }
5162
5163        /// Sets the value of [filter][crate::model::ListPeeringRoutesRequest::filter].
5164        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
5165            self.0.request.filter = v.into();
5166            self
5167        }
5168    }
5169
5170    #[doc(hidden)]
5171    impl gax::options::internal::RequestBuilder for ListPeeringRoutes {
5172        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5173            &mut self.0.options
5174        }
5175    }
5176
5177    /// The request builder for [VmwareEngine::create_hcx_activation_key][crate::client::VmwareEngine::create_hcx_activation_key] calls.
5178    ///
5179    /// # Example
5180    /// ```
5181    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateHcxActivationKey;
5182    /// # async fn sample() -> gax::Result<()> {
5183    /// use lro::Poller;
5184    ///
5185    /// let builder = prepare_request_builder();
5186    /// let response = builder.poller().until_done().await?;
5187    /// # Ok(()) }
5188    ///
5189    /// fn prepare_request_builder() -> CreateHcxActivationKey {
5190    ///   # panic!();
5191    ///   // ... details omitted ...
5192    /// }
5193    /// ```
5194    #[derive(Clone, Debug)]
5195    pub struct CreateHcxActivationKey(RequestBuilder<crate::model::CreateHcxActivationKeyRequest>);
5196
5197    impl CreateHcxActivationKey {
5198        pub(crate) fn new(
5199            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5200        ) -> Self {
5201            Self(RequestBuilder::new(stub))
5202        }
5203
5204        /// Sets the full request, replacing any prior values.
5205        pub fn with_request<V: Into<crate::model::CreateHcxActivationKeyRequest>>(
5206            mut self,
5207            v: V,
5208        ) -> Self {
5209            self.0.request = v.into();
5210            self
5211        }
5212
5213        /// Sets all the options, replacing any prior values.
5214        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
5215            self.0.options = v.into();
5216            self
5217        }
5218
5219        /// Sends the request.
5220        ///
5221        /// # Long running operations
5222        ///
5223        /// This starts, but does not poll, a longrunning operation. More information
5224        /// on [create_hcx_activation_key][crate::client::VmwareEngine::create_hcx_activation_key].
5225        pub async fn send(self) -> Result<longrunning::model::Operation> {
5226            (*self.0.stub)
5227                .create_hcx_activation_key(self.0.request, self.0.options)
5228                .await
5229                .map(gax::response::Response::into_body)
5230        }
5231
5232        /// Creates a [Poller][lro::Poller] to work with `create_hcx_activation_key`.
5233        pub fn poller(
5234            self,
5235        ) -> impl lro::Poller<crate::model::HcxActivationKey, crate::model::OperationMetadata>
5236        {
5237            type Operation = lro::internal::Operation<
5238                crate::model::HcxActivationKey,
5239                crate::model::OperationMetadata,
5240            >;
5241            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
5242            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
5243
5244            let stub = self.0.stub.clone();
5245            let mut options = self.0.options.clone();
5246            options.set_retry_policy(gax::retry_policy::NeverRetry);
5247            let query = move |name| {
5248                let stub = stub.clone();
5249                let options = options.clone();
5250                async {
5251                    let op = GetOperation::new(stub)
5252                        .set_name(name)
5253                        .with_options(options)
5254                        .send()
5255                        .await?;
5256                    Ok(Operation::new(op))
5257                }
5258            };
5259
5260            let start = move || async {
5261                let op = self.send().await?;
5262                Ok(Operation::new(op))
5263            };
5264
5265            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
5266        }
5267
5268        /// Sets the value of [parent][crate::model::CreateHcxActivationKeyRequest::parent].
5269        ///
5270        /// This is a **required** field for requests.
5271        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
5272            self.0.request.parent = v.into();
5273            self
5274        }
5275
5276        /// Sets the value of [hcx_activation_key][crate::model::CreateHcxActivationKeyRequest::hcx_activation_key].
5277        ///
5278        /// This is a **required** field for requests.
5279        pub fn set_hcx_activation_key<T>(mut self, v: T) -> Self
5280        where
5281            T: std::convert::Into<crate::model::HcxActivationKey>,
5282        {
5283            self.0.request.hcx_activation_key = std::option::Option::Some(v.into());
5284            self
5285        }
5286
5287        /// Sets or clears the value of [hcx_activation_key][crate::model::CreateHcxActivationKeyRequest::hcx_activation_key].
5288        ///
5289        /// This is a **required** field for requests.
5290        pub fn set_or_clear_hcx_activation_key<T>(mut self, v: std::option::Option<T>) -> Self
5291        where
5292            T: std::convert::Into<crate::model::HcxActivationKey>,
5293        {
5294            self.0.request.hcx_activation_key = v.map(|x| x.into());
5295            self
5296        }
5297
5298        /// Sets the value of [hcx_activation_key_id][crate::model::CreateHcxActivationKeyRequest::hcx_activation_key_id].
5299        ///
5300        /// This is a **required** field for requests.
5301        pub fn set_hcx_activation_key_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
5302            self.0.request.hcx_activation_key_id = v.into();
5303            self
5304        }
5305
5306        /// Sets the value of [request_id][crate::model::CreateHcxActivationKeyRequest::request_id].
5307        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
5308            self.0.request.request_id = v.into();
5309            self
5310        }
5311    }
5312
5313    #[doc(hidden)]
5314    impl gax::options::internal::RequestBuilder for CreateHcxActivationKey {
5315        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5316            &mut self.0.options
5317        }
5318    }
5319
5320    /// The request builder for [VmwareEngine::list_hcx_activation_keys][crate::client::VmwareEngine::list_hcx_activation_keys] calls.
5321    ///
5322    /// # Example
5323    /// ```
5324    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListHcxActivationKeys;
5325    /// # async fn sample() -> gax::Result<()> {
5326    /// use gax::paginator::ItemPaginator;
5327    ///
5328    /// let builder = prepare_request_builder();
5329    /// let mut items = builder.by_item();
5330    /// while let Some(result) = items.next().await {
5331    ///   let item = result?;
5332    /// }
5333    /// # Ok(()) }
5334    ///
5335    /// fn prepare_request_builder() -> ListHcxActivationKeys {
5336    ///   # panic!();
5337    ///   // ... details omitted ...
5338    /// }
5339    /// ```
5340    #[derive(Clone, Debug)]
5341    pub struct ListHcxActivationKeys(RequestBuilder<crate::model::ListHcxActivationKeysRequest>);
5342
5343    impl ListHcxActivationKeys {
5344        pub(crate) fn new(
5345            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5346        ) -> Self {
5347            Self(RequestBuilder::new(stub))
5348        }
5349
5350        /// Sets the full request, replacing any prior values.
5351        pub fn with_request<V: Into<crate::model::ListHcxActivationKeysRequest>>(
5352            mut self,
5353            v: V,
5354        ) -> Self {
5355            self.0.request = v.into();
5356            self
5357        }
5358
5359        /// Sets all the options, replacing any prior values.
5360        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
5361            self.0.options = v.into();
5362            self
5363        }
5364
5365        /// Sends the request.
5366        pub async fn send(self) -> Result<crate::model::ListHcxActivationKeysResponse> {
5367            (*self.0.stub)
5368                .list_hcx_activation_keys(self.0.request, self.0.options)
5369                .await
5370                .map(gax::response::Response::into_body)
5371        }
5372
5373        /// Streams each page in the collection.
5374        pub fn by_page(
5375            self,
5376        ) -> impl gax::paginator::Paginator<crate::model::ListHcxActivationKeysResponse, gax::error::Error>
5377        {
5378            use std::clone::Clone;
5379            let token = self.0.request.page_token.clone();
5380            let execute = move |token: String| {
5381                let mut builder = self.clone();
5382                builder.0.request = builder.0.request.set_page_token(token);
5383                builder.send()
5384            };
5385            gax::paginator::internal::new_paginator(token, execute)
5386        }
5387
5388        /// Streams each item in the collection.
5389        pub fn by_item(
5390            self,
5391        ) -> impl gax::paginator::ItemPaginator<
5392            crate::model::ListHcxActivationKeysResponse,
5393            gax::error::Error,
5394        > {
5395            use gax::paginator::Paginator;
5396            self.by_page().items()
5397        }
5398
5399        /// Sets the value of [parent][crate::model::ListHcxActivationKeysRequest::parent].
5400        ///
5401        /// This is a **required** field for requests.
5402        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
5403            self.0.request.parent = v.into();
5404            self
5405        }
5406
5407        /// Sets the value of [page_size][crate::model::ListHcxActivationKeysRequest::page_size].
5408        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
5409            self.0.request.page_size = v.into();
5410            self
5411        }
5412
5413        /// Sets the value of [page_token][crate::model::ListHcxActivationKeysRequest::page_token].
5414        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
5415            self.0.request.page_token = v.into();
5416            self
5417        }
5418    }
5419
5420    #[doc(hidden)]
5421    impl gax::options::internal::RequestBuilder for ListHcxActivationKeys {
5422        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5423            &mut self.0.options
5424        }
5425    }
5426
5427    /// The request builder for [VmwareEngine::get_hcx_activation_key][crate::client::VmwareEngine::get_hcx_activation_key] calls.
5428    ///
5429    /// # Example
5430    /// ```
5431    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetHcxActivationKey;
5432    /// # async fn sample() -> gax::Result<()> {
5433    ///
5434    /// let builder = prepare_request_builder();
5435    /// let response = builder.send().await?;
5436    /// # Ok(()) }
5437    ///
5438    /// fn prepare_request_builder() -> GetHcxActivationKey {
5439    ///   # panic!();
5440    ///   // ... details omitted ...
5441    /// }
5442    /// ```
5443    #[derive(Clone, Debug)]
5444    pub struct GetHcxActivationKey(RequestBuilder<crate::model::GetHcxActivationKeyRequest>);
5445
5446    impl GetHcxActivationKey {
5447        pub(crate) fn new(
5448            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5449        ) -> Self {
5450            Self(RequestBuilder::new(stub))
5451        }
5452
5453        /// Sets the full request, replacing any prior values.
5454        pub fn with_request<V: Into<crate::model::GetHcxActivationKeyRequest>>(
5455            mut self,
5456            v: V,
5457        ) -> Self {
5458            self.0.request = v.into();
5459            self
5460        }
5461
5462        /// Sets all the options, replacing any prior values.
5463        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
5464            self.0.options = v.into();
5465            self
5466        }
5467
5468        /// Sends the request.
5469        pub async fn send(self) -> Result<crate::model::HcxActivationKey> {
5470            (*self.0.stub)
5471                .get_hcx_activation_key(self.0.request, self.0.options)
5472                .await
5473                .map(gax::response::Response::into_body)
5474        }
5475
5476        /// Sets the value of [name][crate::model::GetHcxActivationKeyRequest::name].
5477        ///
5478        /// This is a **required** field for requests.
5479        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
5480            self.0.request.name = v.into();
5481            self
5482        }
5483    }
5484
5485    #[doc(hidden)]
5486    impl gax::options::internal::RequestBuilder for GetHcxActivationKey {
5487        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5488            &mut self.0.options
5489        }
5490    }
5491
5492    /// The request builder for [VmwareEngine::get_network_policy][crate::client::VmwareEngine::get_network_policy] calls.
5493    ///
5494    /// # Example
5495    /// ```
5496    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetNetworkPolicy;
5497    /// # async fn sample() -> gax::Result<()> {
5498    ///
5499    /// let builder = prepare_request_builder();
5500    /// let response = builder.send().await?;
5501    /// # Ok(()) }
5502    ///
5503    /// fn prepare_request_builder() -> GetNetworkPolicy {
5504    ///   # panic!();
5505    ///   // ... details omitted ...
5506    /// }
5507    /// ```
5508    #[derive(Clone, Debug)]
5509    pub struct GetNetworkPolicy(RequestBuilder<crate::model::GetNetworkPolicyRequest>);
5510
5511    impl GetNetworkPolicy {
5512        pub(crate) fn new(
5513            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5514        ) -> Self {
5515            Self(RequestBuilder::new(stub))
5516        }
5517
5518        /// Sets the full request, replacing any prior values.
5519        pub fn with_request<V: Into<crate::model::GetNetworkPolicyRequest>>(
5520            mut self,
5521            v: V,
5522        ) -> Self {
5523            self.0.request = v.into();
5524            self
5525        }
5526
5527        /// Sets all the options, replacing any prior values.
5528        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
5529            self.0.options = v.into();
5530            self
5531        }
5532
5533        /// Sends the request.
5534        pub async fn send(self) -> Result<crate::model::NetworkPolicy> {
5535            (*self.0.stub)
5536                .get_network_policy(self.0.request, self.0.options)
5537                .await
5538                .map(gax::response::Response::into_body)
5539        }
5540
5541        /// Sets the value of [name][crate::model::GetNetworkPolicyRequest::name].
5542        ///
5543        /// This is a **required** field for requests.
5544        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
5545            self.0.request.name = v.into();
5546            self
5547        }
5548    }
5549
5550    #[doc(hidden)]
5551    impl gax::options::internal::RequestBuilder for GetNetworkPolicy {
5552        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5553            &mut self.0.options
5554        }
5555    }
5556
5557    /// The request builder for [VmwareEngine::list_network_policies][crate::client::VmwareEngine::list_network_policies] calls.
5558    ///
5559    /// # Example
5560    /// ```
5561    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListNetworkPolicies;
5562    /// # async fn sample() -> gax::Result<()> {
5563    /// use gax::paginator::ItemPaginator;
5564    ///
5565    /// let builder = prepare_request_builder();
5566    /// let mut items = builder.by_item();
5567    /// while let Some(result) = items.next().await {
5568    ///   let item = result?;
5569    /// }
5570    /// # Ok(()) }
5571    ///
5572    /// fn prepare_request_builder() -> ListNetworkPolicies {
5573    ///   # panic!();
5574    ///   // ... details omitted ...
5575    /// }
5576    /// ```
5577    #[derive(Clone, Debug)]
5578    pub struct ListNetworkPolicies(RequestBuilder<crate::model::ListNetworkPoliciesRequest>);
5579
5580    impl ListNetworkPolicies {
5581        pub(crate) fn new(
5582            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5583        ) -> Self {
5584            Self(RequestBuilder::new(stub))
5585        }
5586
5587        /// Sets the full request, replacing any prior values.
5588        pub fn with_request<V: Into<crate::model::ListNetworkPoliciesRequest>>(
5589            mut self,
5590            v: V,
5591        ) -> Self {
5592            self.0.request = v.into();
5593            self
5594        }
5595
5596        /// Sets all the options, replacing any prior values.
5597        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
5598            self.0.options = v.into();
5599            self
5600        }
5601
5602        /// Sends the request.
5603        pub async fn send(self) -> Result<crate::model::ListNetworkPoliciesResponse> {
5604            (*self.0.stub)
5605                .list_network_policies(self.0.request, self.0.options)
5606                .await
5607                .map(gax::response::Response::into_body)
5608        }
5609
5610        /// Streams each page in the collection.
5611        pub fn by_page(
5612            self,
5613        ) -> impl gax::paginator::Paginator<crate::model::ListNetworkPoliciesResponse, gax::error::Error>
5614        {
5615            use std::clone::Clone;
5616            let token = self.0.request.page_token.clone();
5617            let execute = move |token: String| {
5618                let mut builder = self.clone();
5619                builder.0.request = builder.0.request.set_page_token(token);
5620                builder.send()
5621            };
5622            gax::paginator::internal::new_paginator(token, execute)
5623        }
5624
5625        /// Streams each item in the collection.
5626        pub fn by_item(
5627            self,
5628        ) -> impl gax::paginator::ItemPaginator<
5629            crate::model::ListNetworkPoliciesResponse,
5630            gax::error::Error,
5631        > {
5632            use gax::paginator::Paginator;
5633            self.by_page().items()
5634        }
5635
5636        /// Sets the value of [parent][crate::model::ListNetworkPoliciesRequest::parent].
5637        ///
5638        /// This is a **required** field for requests.
5639        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
5640            self.0.request.parent = v.into();
5641            self
5642        }
5643
5644        /// Sets the value of [page_size][crate::model::ListNetworkPoliciesRequest::page_size].
5645        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
5646            self.0.request.page_size = v.into();
5647            self
5648        }
5649
5650        /// Sets the value of [page_token][crate::model::ListNetworkPoliciesRequest::page_token].
5651        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
5652            self.0.request.page_token = v.into();
5653            self
5654        }
5655
5656        /// Sets the value of [filter][crate::model::ListNetworkPoliciesRequest::filter].
5657        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
5658            self.0.request.filter = v.into();
5659            self
5660        }
5661
5662        /// Sets the value of [order_by][crate::model::ListNetworkPoliciesRequest::order_by].
5663        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
5664            self.0.request.order_by = v.into();
5665            self
5666        }
5667    }
5668
5669    #[doc(hidden)]
5670    impl gax::options::internal::RequestBuilder for ListNetworkPolicies {
5671        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5672            &mut self.0.options
5673        }
5674    }
5675
5676    /// The request builder for [VmwareEngine::create_network_policy][crate::client::VmwareEngine::create_network_policy] calls.
5677    ///
5678    /// # Example
5679    /// ```
5680    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateNetworkPolicy;
5681    /// # async fn sample() -> gax::Result<()> {
5682    /// use lro::Poller;
5683    ///
5684    /// let builder = prepare_request_builder();
5685    /// let response = builder.poller().until_done().await?;
5686    /// # Ok(()) }
5687    ///
5688    /// fn prepare_request_builder() -> CreateNetworkPolicy {
5689    ///   # panic!();
5690    ///   // ... details omitted ...
5691    /// }
5692    /// ```
5693    #[derive(Clone, Debug)]
5694    pub struct CreateNetworkPolicy(RequestBuilder<crate::model::CreateNetworkPolicyRequest>);
5695
5696    impl CreateNetworkPolicy {
5697        pub(crate) fn new(
5698            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5699        ) -> Self {
5700            Self(RequestBuilder::new(stub))
5701        }
5702
5703        /// Sets the full request, replacing any prior values.
5704        pub fn with_request<V: Into<crate::model::CreateNetworkPolicyRequest>>(
5705            mut self,
5706            v: V,
5707        ) -> Self {
5708            self.0.request = v.into();
5709            self
5710        }
5711
5712        /// Sets all the options, replacing any prior values.
5713        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
5714            self.0.options = v.into();
5715            self
5716        }
5717
5718        /// Sends the request.
5719        ///
5720        /// # Long running operations
5721        ///
5722        /// This starts, but does not poll, a longrunning operation. More information
5723        /// on [create_network_policy][crate::client::VmwareEngine::create_network_policy].
5724        pub async fn send(self) -> Result<longrunning::model::Operation> {
5725            (*self.0.stub)
5726                .create_network_policy(self.0.request, self.0.options)
5727                .await
5728                .map(gax::response::Response::into_body)
5729        }
5730
5731        /// Creates a [Poller][lro::Poller] to work with `create_network_policy`.
5732        pub fn poller(
5733            self,
5734        ) -> impl lro::Poller<crate::model::NetworkPolicy, crate::model::OperationMetadata>
5735        {
5736            type Operation = lro::internal::Operation<
5737                crate::model::NetworkPolicy,
5738                crate::model::OperationMetadata,
5739            >;
5740            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
5741            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
5742
5743            let stub = self.0.stub.clone();
5744            let mut options = self.0.options.clone();
5745            options.set_retry_policy(gax::retry_policy::NeverRetry);
5746            let query = move |name| {
5747                let stub = stub.clone();
5748                let options = options.clone();
5749                async {
5750                    let op = GetOperation::new(stub)
5751                        .set_name(name)
5752                        .with_options(options)
5753                        .send()
5754                        .await?;
5755                    Ok(Operation::new(op))
5756                }
5757            };
5758
5759            let start = move || async {
5760                let op = self.send().await?;
5761                Ok(Operation::new(op))
5762            };
5763
5764            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
5765        }
5766
5767        /// Sets the value of [parent][crate::model::CreateNetworkPolicyRequest::parent].
5768        ///
5769        /// This is a **required** field for requests.
5770        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
5771            self.0.request.parent = v.into();
5772            self
5773        }
5774
5775        /// Sets the value of [network_policy_id][crate::model::CreateNetworkPolicyRequest::network_policy_id].
5776        ///
5777        /// This is a **required** field for requests.
5778        pub fn set_network_policy_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
5779            self.0.request.network_policy_id = v.into();
5780            self
5781        }
5782
5783        /// Sets the value of [network_policy][crate::model::CreateNetworkPolicyRequest::network_policy].
5784        ///
5785        /// This is a **required** field for requests.
5786        pub fn set_network_policy<T>(mut self, v: T) -> Self
5787        where
5788            T: std::convert::Into<crate::model::NetworkPolicy>,
5789        {
5790            self.0.request.network_policy = std::option::Option::Some(v.into());
5791            self
5792        }
5793
5794        /// Sets or clears the value of [network_policy][crate::model::CreateNetworkPolicyRequest::network_policy].
5795        ///
5796        /// This is a **required** field for requests.
5797        pub fn set_or_clear_network_policy<T>(mut self, v: std::option::Option<T>) -> Self
5798        where
5799            T: std::convert::Into<crate::model::NetworkPolicy>,
5800        {
5801            self.0.request.network_policy = v.map(|x| x.into());
5802            self
5803        }
5804
5805        /// Sets the value of [request_id][crate::model::CreateNetworkPolicyRequest::request_id].
5806        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
5807            self.0.request.request_id = v.into();
5808            self
5809        }
5810    }
5811
5812    #[doc(hidden)]
5813    impl gax::options::internal::RequestBuilder for CreateNetworkPolicy {
5814        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5815            &mut self.0.options
5816        }
5817    }
5818
5819    /// The request builder for [VmwareEngine::update_network_policy][crate::client::VmwareEngine::update_network_policy] calls.
5820    ///
5821    /// # Example
5822    /// ```
5823    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateNetworkPolicy;
5824    /// # async fn sample() -> gax::Result<()> {
5825    /// use lro::Poller;
5826    ///
5827    /// let builder = prepare_request_builder();
5828    /// let response = builder.poller().until_done().await?;
5829    /// # Ok(()) }
5830    ///
5831    /// fn prepare_request_builder() -> UpdateNetworkPolicy {
5832    ///   # panic!();
5833    ///   // ... details omitted ...
5834    /// }
5835    /// ```
5836    #[derive(Clone, Debug)]
5837    pub struct UpdateNetworkPolicy(RequestBuilder<crate::model::UpdateNetworkPolicyRequest>);
5838
5839    impl UpdateNetworkPolicy {
5840        pub(crate) fn new(
5841            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5842        ) -> Self {
5843            Self(RequestBuilder::new(stub))
5844        }
5845
5846        /// Sets the full request, replacing any prior values.
5847        pub fn with_request<V: Into<crate::model::UpdateNetworkPolicyRequest>>(
5848            mut self,
5849            v: V,
5850        ) -> Self {
5851            self.0.request = v.into();
5852            self
5853        }
5854
5855        /// Sets all the options, replacing any prior values.
5856        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
5857            self.0.options = v.into();
5858            self
5859        }
5860
5861        /// Sends the request.
5862        ///
5863        /// # Long running operations
5864        ///
5865        /// This starts, but does not poll, a longrunning operation. More information
5866        /// on [update_network_policy][crate::client::VmwareEngine::update_network_policy].
5867        pub async fn send(self) -> Result<longrunning::model::Operation> {
5868            (*self.0.stub)
5869                .update_network_policy(self.0.request, self.0.options)
5870                .await
5871                .map(gax::response::Response::into_body)
5872        }
5873
5874        /// Creates a [Poller][lro::Poller] to work with `update_network_policy`.
5875        pub fn poller(
5876            self,
5877        ) -> impl lro::Poller<crate::model::NetworkPolicy, crate::model::OperationMetadata>
5878        {
5879            type Operation = lro::internal::Operation<
5880                crate::model::NetworkPolicy,
5881                crate::model::OperationMetadata,
5882            >;
5883            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
5884            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
5885
5886            let stub = self.0.stub.clone();
5887            let mut options = self.0.options.clone();
5888            options.set_retry_policy(gax::retry_policy::NeverRetry);
5889            let query = move |name| {
5890                let stub = stub.clone();
5891                let options = options.clone();
5892                async {
5893                    let op = GetOperation::new(stub)
5894                        .set_name(name)
5895                        .with_options(options)
5896                        .send()
5897                        .await?;
5898                    Ok(Operation::new(op))
5899                }
5900            };
5901
5902            let start = move || async {
5903                let op = self.send().await?;
5904                Ok(Operation::new(op))
5905            };
5906
5907            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
5908        }
5909
5910        /// Sets the value of [network_policy][crate::model::UpdateNetworkPolicyRequest::network_policy].
5911        ///
5912        /// This is a **required** field for requests.
5913        pub fn set_network_policy<T>(mut self, v: T) -> Self
5914        where
5915            T: std::convert::Into<crate::model::NetworkPolicy>,
5916        {
5917            self.0.request.network_policy = std::option::Option::Some(v.into());
5918            self
5919        }
5920
5921        /// Sets or clears the value of [network_policy][crate::model::UpdateNetworkPolicyRequest::network_policy].
5922        ///
5923        /// This is a **required** field for requests.
5924        pub fn set_or_clear_network_policy<T>(mut self, v: std::option::Option<T>) -> Self
5925        where
5926            T: std::convert::Into<crate::model::NetworkPolicy>,
5927        {
5928            self.0.request.network_policy = v.map(|x| x.into());
5929            self
5930        }
5931
5932        /// Sets the value of [update_mask][crate::model::UpdateNetworkPolicyRequest::update_mask].
5933        ///
5934        /// This is a **required** field for requests.
5935        pub fn set_update_mask<T>(mut self, v: T) -> Self
5936        where
5937            T: std::convert::Into<wkt::FieldMask>,
5938        {
5939            self.0.request.update_mask = std::option::Option::Some(v.into());
5940            self
5941        }
5942
5943        /// Sets or clears the value of [update_mask][crate::model::UpdateNetworkPolicyRequest::update_mask].
5944        ///
5945        /// This is a **required** field for requests.
5946        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
5947        where
5948            T: std::convert::Into<wkt::FieldMask>,
5949        {
5950            self.0.request.update_mask = v.map(|x| x.into());
5951            self
5952        }
5953
5954        /// Sets the value of [request_id][crate::model::UpdateNetworkPolicyRequest::request_id].
5955        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
5956            self.0.request.request_id = v.into();
5957            self
5958        }
5959    }
5960
5961    #[doc(hidden)]
5962    impl gax::options::internal::RequestBuilder for UpdateNetworkPolicy {
5963        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
5964            &mut self.0.options
5965        }
5966    }
5967
5968    /// The request builder for [VmwareEngine::delete_network_policy][crate::client::VmwareEngine::delete_network_policy] calls.
5969    ///
5970    /// # Example
5971    /// ```
5972    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteNetworkPolicy;
5973    /// # async fn sample() -> gax::Result<()> {
5974    /// use lro::Poller;
5975    ///
5976    /// let builder = prepare_request_builder();
5977    /// let response = builder.poller().until_done().await?;
5978    /// # Ok(()) }
5979    ///
5980    /// fn prepare_request_builder() -> DeleteNetworkPolicy {
5981    ///   # panic!();
5982    ///   // ... details omitted ...
5983    /// }
5984    /// ```
5985    #[derive(Clone, Debug)]
5986    pub struct DeleteNetworkPolicy(RequestBuilder<crate::model::DeleteNetworkPolicyRequest>);
5987
5988    impl DeleteNetworkPolicy {
5989        pub(crate) fn new(
5990            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
5991        ) -> Self {
5992            Self(RequestBuilder::new(stub))
5993        }
5994
5995        /// Sets the full request, replacing any prior values.
5996        pub fn with_request<V: Into<crate::model::DeleteNetworkPolicyRequest>>(
5997            mut self,
5998            v: V,
5999        ) -> Self {
6000            self.0.request = v.into();
6001            self
6002        }
6003
6004        /// Sets all the options, replacing any prior values.
6005        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6006            self.0.options = v.into();
6007            self
6008        }
6009
6010        /// Sends the request.
6011        ///
6012        /// # Long running operations
6013        ///
6014        /// This starts, but does not poll, a longrunning operation. More information
6015        /// on [delete_network_policy][crate::client::VmwareEngine::delete_network_policy].
6016        pub async fn send(self) -> Result<longrunning::model::Operation> {
6017            (*self.0.stub)
6018                .delete_network_policy(self.0.request, self.0.options)
6019                .await
6020                .map(gax::response::Response::into_body)
6021        }
6022
6023        /// Creates a [Poller][lro::Poller] to work with `delete_network_policy`.
6024        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
6025            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
6026            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
6027            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
6028
6029            let stub = self.0.stub.clone();
6030            let mut options = self.0.options.clone();
6031            options.set_retry_policy(gax::retry_policy::NeverRetry);
6032            let query = move |name| {
6033                let stub = stub.clone();
6034                let options = options.clone();
6035                async {
6036                    let op = GetOperation::new(stub)
6037                        .set_name(name)
6038                        .with_options(options)
6039                        .send()
6040                        .await?;
6041                    Ok(Operation::new(op))
6042                }
6043            };
6044
6045            let start = move || async {
6046                let op = self.send().await?;
6047                Ok(Operation::new(op))
6048            };
6049
6050            lro::internal::new_unit_response_poller(
6051                polling_error_policy,
6052                polling_backoff_policy,
6053                start,
6054                query,
6055            )
6056        }
6057
6058        /// Sets the value of [name][crate::model::DeleteNetworkPolicyRequest::name].
6059        ///
6060        /// This is a **required** field for requests.
6061        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
6062            self.0.request.name = v.into();
6063            self
6064        }
6065
6066        /// Sets the value of [request_id][crate::model::DeleteNetworkPolicyRequest::request_id].
6067        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
6068            self.0.request.request_id = v.into();
6069            self
6070        }
6071    }
6072
6073    #[doc(hidden)]
6074    impl gax::options::internal::RequestBuilder for DeleteNetworkPolicy {
6075        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
6076            &mut self.0.options
6077        }
6078    }
6079
6080    /// The request builder for [VmwareEngine::list_management_dns_zone_bindings][crate::client::VmwareEngine::list_management_dns_zone_bindings] calls.
6081    ///
6082    /// # Example
6083    /// ```
6084    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListManagementDnsZoneBindings;
6085    /// # async fn sample() -> gax::Result<()> {
6086    /// use gax::paginator::ItemPaginator;
6087    ///
6088    /// let builder = prepare_request_builder();
6089    /// let mut items = builder.by_item();
6090    /// while let Some(result) = items.next().await {
6091    ///   let item = result?;
6092    /// }
6093    /// # Ok(()) }
6094    ///
6095    /// fn prepare_request_builder() -> ListManagementDnsZoneBindings {
6096    ///   # panic!();
6097    ///   // ... details omitted ...
6098    /// }
6099    /// ```
6100    #[derive(Clone, Debug)]
6101    pub struct ListManagementDnsZoneBindings(
6102        RequestBuilder<crate::model::ListManagementDnsZoneBindingsRequest>,
6103    );
6104
6105    impl ListManagementDnsZoneBindings {
6106        pub(crate) fn new(
6107            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
6108        ) -> Self {
6109            Self(RequestBuilder::new(stub))
6110        }
6111
6112        /// Sets the full request, replacing any prior values.
6113        pub fn with_request<V: Into<crate::model::ListManagementDnsZoneBindingsRequest>>(
6114            mut self,
6115            v: V,
6116        ) -> Self {
6117            self.0.request = v.into();
6118            self
6119        }
6120
6121        /// Sets all the options, replacing any prior values.
6122        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6123            self.0.options = v.into();
6124            self
6125        }
6126
6127        /// Sends the request.
6128        pub async fn send(self) -> Result<crate::model::ListManagementDnsZoneBindingsResponse> {
6129            (*self.0.stub)
6130                .list_management_dns_zone_bindings(self.0.request, self.0.options)
6131                .await
6132                .map(gax::response::Response::into_body)
6133        }
6134
6135        /// Streams each page in the collection.
6136        pub fn by_page(
6137            self,
6138        ) -> impl gax::paginator::Paginator<
6139            crate::model::ListManagementDnsZoneBindingsResponse,
6140            gax::error::Error,
6141        > {
6142            use std::clone::Clone;
6143            let token = self.0.request.page_token.clone();
6144            let execute = move |token: String| {
6145                let mut builder = self.clone();
6146                builder.0.request = builder.0.request.set_page_token(token);
6147                builder.send()
6148            };
6149            gax::paginator::internal::new_paginator(token, execute)
6150        }
6151
6152        /// Streams each item in the collection.
6153        pub fn by_item(
6154            self,
6155        ) -> impl gax::paginator::ItemPaginator<
6156            crate::model::ListManagementDnsZoneBindingsResponse,
6157            gax::error::Error,
6158        > {
6159            use gax::paginator::Paginator;
6160            self.by_page().items()
6161        }
6162
6163        /// Sets the value of [parent][crate::model::ListManagementDnsZoneBindingsRequest::parent].
6164        ///
6165        /// This is a **required** field for requests.
6166        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
6167            self.0.request.parent = v.into();
6168            self
6169        }
6170
6171        /// Sets the value of [page_size][crate::model::ListManagementDnsZoneBindingsRequest::page_size].
6172        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
6173            self.0.request.page_size = v.into();
6174            self
6175        }
6176
6177        /// Sets the value of [page_token][crate::model::ListManagementDnsZoneBindingsRequest::page_token].
6178        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
6179            self.0.request.page_token = v.into();
6180            self
6181        }
6182
6183        /// Sets the value of [filter][crate::model::ListManagementDnsZoneBindingsRequest::filter].
6184        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
6185            self.0.request.filter = v.into();
6186            self
6187        }
6188
6189        /// Sets the value of [order_by][crate::model::ListManagementDnsZoneBindingsRequest::order_by].
6190        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
6191            self.0.request.order_by = v.into();
6192            self
6193        }
6194    }
6195
6196    #[doc(hidden)]
6197    impl gax::options::internal::RequestBuilder for ListManagementDnsZoneBindings {
6198        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
6199            &mut self.0.options
6200        }
6201    }
6202
6203    /// The request builder for [VmwareEngine::get_management_dns_zone_binding][crate::client::VmwareEngine::get_management_dns_zone_binding] calls.
6204    ///
6205    /// # Example
6206    /// ```
6207    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetManagementDnsZoneBinding;
6208    /// # async fn sample() -> gax::Result<()> {
6209    ///
6210    /// let builder = prepare_request_builder();
6211    /// let response = builder.send().await?;
6212    /// # Ok(()) }
6213    ///
6214    /// fn prepare_request_builder() -> GetManagementDnsZoneBinding {
6215    ///   # panic!();
6216    ///   // ... details omitted ...
6217    /// }
6218    /// ```
6219    #[derive(Clone, Debug)]
6220    pub struct GetManagementDnsZoneBinding(
6221        RequestBuilder<crate::model::GetManagementDnsZoneBindingRequest>,
6222    );
6223
6224    impl GetManagementDnsZoneBinding {
6225        pub(crate) fn new(
6226            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
6227        ) -> Self {
6228            Self(RequestBuilder::new(stub))
6229        }
6230
6231        /// Sets the full request, replacing any prior values.
6232        pub fn with_request<V: Into<crate::model::GetManagementDnsZoneBindingRequest>>(
6233            mut self,
6234            v: V,
6235        ) -> Self {
6236            self.0.request = v.into();
6237            self
6238        }
6239
6240        /// Sets all the options, replacing any prior values.
6241        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6242            self.0.options = v.into();
6243            self
6244        }
6245
6246        /// Sends the request.
6247        pub async fn send(self) -> Result<crate::model::ManagementDnsZoneBinding> {
6248            (*self.0.stub)
6249                .get_management_dns_zone_binding(self.0.request, self.0.options)
6250                .await
6251                .map(gax::response::Response::into_body)
6252        }
6253
6254        /// Sets the value of [name][crate::model::GetManagementDnsZoneBindingRequest::name].
6255        ///
6256        /// This is a **required** field for requests.
6257        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
6258            self.0.request.name = v.into();
6259            self
6260        }
6261    }
6262
6263    #[doc(hidden)]
6264    impl gax::options::internal::RequestBuilder for GetManagementDnsZoneBinding {
6265        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
6266            &mut self.0.options
6267        }
6268    }
6269
6270    /// The request builder for [VmwareEngine::create_management_dns_zone_binding][crate::client::VmwareEngine::create_management_dns_zone_binding] calls.
6271    ///
6272    /// # Example
6273    /// ```
6274    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateManagementDnsZoneBinding;
6275    /// # async fn sample() -> gax::Result<()> {
6276    /// use lro::Poller;
6277    ///
6278    /// let builder = prepare_request_builder();
6279    /// let response = builder.poller().until_done().await?;
6280    /// # Ok(()) }
6281    ///
6282    /// fn prepare_request_builder() -> CreateManagementDnsZoneBinding {
6283    ///   # panic!();
6284    ///   // ... details omitted ...
6285    /// }
6286    /// ```
6287    #[derive(Clone, Debug)]
6288    pub struct CreateManagementDnsZoneBinding(
6289        RequestBuilder<crate::model::CreateManagementDnsZoneBindingRequest>,
6290    );
6291
6292    impl CreateManagementDnsZoneBinding {
6293        pub(crate) fn new(
6294            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
6295        ) -> Self {
6296            Self(RequestBuilder::new(stub))
6297        }
6298
6299        /// Sets the full request, replacing any prior values.
6300        pub fn with_request<V: Into<crate::model::CreateManagementDnsZoneBindingRequest>>(
6301            mut self,
6302            v: V,
6303        ) -> Self {
6304            self.0.request = v.into();
6305            self
6306        }
6307
6308        /// Sets all the options, replacing any prior values.
6309        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6310            self.0.options = v.into();
6311            self
6312        }
6313
6314        /// Sends the request.
6315        ///
6316        /// # Long running operations
6317        ///
6318        /// This starts, but does not poll, a longrunning operation. More information
6319        /// on [create_management_dns_zone_binding][crate::client::VmwareEngine::create_management_dns_zone_binding].
6320        pub async fn send(self) -> Result<longrunning::model::Operation> {
6321            (*self.0.stub)
6322                .create_management_dns_zone_binding(self.0.request, self.0.options)
6323                .await
6324                .map(gax::response::Response::into_body)
6325        }
6326
6327        /// Creates a [Poller][lro::Poller] to work with `create_management_dns_zone_binding`.
6328        pub fn poller(
6329            self,
6330        ) -> impl lro::Poller<crate::model::ManagementDnsZoneBinding, crate::model::OperationMetadata>
6331        {
6332            type Operation = lro::internal::Operation<
6333                crate::model::ManagementDnsZoneBinding,
6334                crate::model::OperationMetadata,
6335            >;
6336            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
6337            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
6338
6339            let stub = self.0.stub.clone();
6340            let mut options = self.0.options.clone();
6341            options.set_retry_policy(gax::retry_policy::NeverRetry);
6342            let query = move |name| {
6343                let stub = stub.clone();
6344                let options = options.clone();
6345                async {
6346                    let op = GetOperation::new(stub)
6347                        .set_name(name)
6348                        .with_options(options)
6349                        .send()
6350                        .await?;
6351                    Ok(Operation::new(op))
6352                }
6353            };
6354
6355            let start = move || async {
6356                let op = self.send().await?;
6357                Ok(Operation::new(op))
6358            };
6359
6360            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
6361        }
6362
6363        /// Sets the value of [parent][crate::model::CreateManagementDnsZoneBindingRequest::parent].
6364        ///
6365        /// This is a **required** field for requests.
6366        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
6367            self.0.request.parent = v.into();
6368            self
6369        }
6370
6371        /// Sets the value of [management_dns_zone_binding][crate::model::CreateManagementDnsZoneBindingRequest::management_dns_zone_binding].
6372        ///
6373        /// This is a **required** field for requests.
6374        pub fn set_management_dns_zone_binding<T>(mut self, v: T) -> Self
6375        where
6376            T: std::convert::Into<crate::model::ManagementDnsZoneBinding>,
6377        {
6378            self.0.request.management_dns_zone_binding = std::option::Option::Some(v.into());
6379            self
6380        }
6381
6382        /// Sets or clears the value of [management_dns_zone_binding][crate::model::CreateManagementDnsZoneBindingRequest::management_dns_zone_binding].
6383        ///
6384        /// This is a **required** field for requests.
6385        pub fn set_or_clear_management_dns_zone_binding<T>(
6386            mut self,
6387            v: std::option::Option<T>,
6388        ) -> Self
6389        where
6390            T: std::convert::Into<crate::model::ManagementDnsZoneBinding>,
6391        {
6392            self.0.request.management_dns_zone_binding = v.map(|x| x.into());
6393            self
6394        }
6395
6396        /// Sets the value of [management_dns_zone_binding_id][crate::model::CreateManagementDnsZoneBindingRequest::management_dns_zone_binding_id].
6397        ///
6398        /// This is a **required** field for requests.
6399        pub fn set_management_dns_zone_binding_id<T: Into<std::string::String>>(
6400            mut self,
6401            v: T,
6402        ) -> Self {
6403            self.0.request.management_dns_zone_binding_id = v.into();
6404            self
6405        }
6406
6407        /// Sets the value of [request_id][crate::model::CreateManagementDnsZoneBindingRequest::request_id].
6408        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
6409            self.0.request.request_id = v.into();
6410            self
6411        }
6412    }
6413
6414    #[doc(hidden)]
6415    impl gax::options::internal::RequestBuilder for CreateManagementDnsZoneBinding {
6416        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
6417            &mut self.0.options
6418        }
6419    }
6420
6421    /// The request builder for [VmwareEngine::update_management_dns_zone_binding][crate::client::VmwareEngine::update_management_dns_zone_binding] calls.
6422    ///
6423    /// # Example
6424    /// ```
6425    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateManagementDnsZoneBinding;
6426    /// # async fn sample() -> gax::Result<()> {
6427    /// use lro::Poller;
6428    ///
6429    /// let builder = prepare_request_builder();
6430    /// let response = builder.poller().until_done().await?;
6431    /// # Ok(()) }
6432    ///
6433    /// fn prepare_request_builder() -> UpdateManagementDnsZoneBinding {
6434    ///   # panic!();
6435    ///   // ... details omitted ...
6436    /// }
6437    /// ```
6438    #[derive(Clone, Debug)]
6439    pub struct UpdateManagementDnsZoneBinding(
6440        RequestBuilder<crate::model::UpdateManagementDnsZoneBindingRequest>,
6441    );
6442
6443    impl UpdateManagementDnsZoneBinding {
6444        pub(crate) fn new(
6445            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
6446        ) -> Self {
6447            Self(RequestBuilder::new(stub))
6448        }
6449
6450        /// Sets the full request, replacing any prior values.
6451        pub fn with_request<V: Into<crate::model::UpdateManagementDnsZoneBindingRequest>>(
6452            mut self,
6453            v: V,
6454        ) -> Self {
6455            self.0.request = v.into();
6456            self
6457        }
6458
6459        /// Sets all the options, replacing any prior values.
6460        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6461            self.0.options = v.into();
6462            self
6463        }
6464
6465        /// Sends the request.
6466        ///
6467        /// # Long running operations
6468        ///
6469        /// This starts, but does not poll, a longrunning operation. More information
6470        /// on [update_management_dns_zone_binding][crate::client::VmwareEngine::update_management_dns_zone_binding].
6471        pub async fn send(self) -> Result<longrunning::model::Operation> {
6472            (*self.0.stub)
6473                .update_management_dns_zone_binding(self.0.request, self.0.options)
6474                .await
6475                .map(gax::response::Response::into_body)
6476        }
6477
6478        /// Creates a [Poller][lro::Poller] to work with `update_management_dns_zone_binding`.
6479        pub fn poller(
6480            self,
6481        ) -> impl lro::Poller<crate::model::ManagementDnsZoneBinding, crate::model::OperationMetadata>
6482        {
6483            type Operation = lro::internal::Operation<
6484                crate::model::ManagementDnsZoneBinding,
6485                crate::model::OperationMetadata,
6486            >;
6487            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
6488            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
6489
6490            let stub = self.0.stub.clone();
6491            let mut options = self.0.options.clone();
6492            options.set_retry_policy(gax::retry_policy::NeverRetry);
6493            let query = move |name| {
6494                let stub = stub.clone();
6495                let options = options.clone();
6496                async {
6497                    let op = GetOperation::new(stub)
6498                        .set_name(name)
6499                        .with_options(options)
6500                        .send()
6501                        .await?;
6502                    Ok(Operation::new(op))
6503                }
6504            };
6505
6506            let start = move || async {
6507                let op = self.send().await?;
6508                Ok(Operation::new(op))
6509            };
6510
6511            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
6512        }
6513
6514        /// Sets the value of [update_mask][crate::model::UpdateManagementDnsZoneBindingRequest::update_mask].
6515        ///
6516        /// This is a **required** field for requests.
6517        pub fn set_update_mask<T>(mut self, v: T) -> Self
6518        where
6519            T: std::convert::Into<wkt::FieldMask>,
6520        {
6521            self.0.request.update_mask = std::option::Option::Some(v.into());
6522            self
6523        }
6524
6525        /// Sets or clears the value of [update_mask][crate::model::UpdateManagementDnsZoneBindingRequest::update_mask].
6526        ///
6527        /// This is a **required** field for requests.
6528        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
6529        where
6530            T: std::convert::Into<wkt::FieldMask>,
6531        {
6532            self.0.request.update_mask = v.map(|x| x.into());
6533            self
6534        }
6535
6536        /// Sets the value of [management_dns_zone_binding][crate::model::UpdateManagementDnsZoneBindingRequest::management_dns_zone_binding].
6537        ///
6538        /// This is a **required** field for requests.
6539        pub fn set_management_dns_zone_binding<T>(mut self, v: T) -> Self
6540        where
6541            T: std::convert::Into<crate::model::ManagementDnsZoneBinding>,
6542        {
6543            self.0.request.management_dns_zone_binding = std::option::Option::Some(v.into());
6544            self
6545        }
6546
6547        /// Sets or clears the value of [management_dns_zone_binding][crate::model::UpdateManagementDnsZoneBindingRequest::management_dns_zone_binding].
6548        ///
6549        /// This is a **required** field for requests.
6550        pub fn set_or_clear_management_dns_zone_binding<T>(
6551            mut self,
6552            v: std::option::Option<T>,
6553        ) -> Self
6554        where
6555            T: std::convert::Into<crate::model::ManagementDnsZoneBinding>,
6556        {
6557            self.0.request.management_dns_zone_binding = v.map(|x| x.into());
6558            self
6559        }
6560
6561        /// Sets the value of [request_id][crate::model::UpdateManagementDnsZoneBindingRequest::request_id].
6562        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
6563            self.0.request.request_id = v.into();
6564            self
6565        }
6566    }
6567
6568    #[doc(hidden)]
6569    impl gax::options::internal::RequestBuilder for UpdateManagementDnsZoneBinding {
6570        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
6571            &mut self.0.options
6572        }
6573    }
6574
6575    /// The request builder for [VmwareEngine::delete_management_dns_zone_binding][crate::client::VmwareEngine::delete_management_dns_zone_binding] calls.
6576    ///
6577    /// # Example
6578    /// ```
6579    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteManagementDnsZoneBinding;
6580    /// # async fn sample() -> gax::Result<()> {
6581    /// use lro::Poller;
6582    ///
6583    /// let builder = prepare_request_builder();
6584    /// let response = builder.poller().until_done().await?;
6585    /// # Ok(()) }
6586    ///
6587    /// fn prepare_request_builder() -> DeleteManagementDnsZoneBinding {
6588    ///   # panic!();
6589    ///   // ... details omitted ...
6590    /// }
6591    /// ```
6592    #[derive(Clone, Debug)]
6593    pub struct DeleteManagementDnsZoneBinding(
6594        RequestBuilder<crate::model::DeleteManagementDnsZoneBindingRequest>,
6595    );
6596
6597    impl DeleteManagementDnsZoneBinding {
6598        pub(crate) fn new(
6599            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
6600        ) -> Self {
6601            Self(RequestBuilder::new(stub))
6602        }
6603
6604        /// Sets the full request, replacing any prior values.
6605        pub fn with_request<V: Into<crate::model::DeleteManagementDnsZoneBindingRequest>>(
6606            mut self,
6607            v: V,
6608        ) -> Self {
6609            self.0.request = v.into();
6610            self
6611        }
6612
6613        /// Sets all the options, replacing any prior values.
6614        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6615            self.0.options = v.into();
6616            self
6617        }
6618
6619        /// Sends the request.
6620        ///
6621        /// # Long running operations
6622        ///
6623        /// This starts, but does not poll, a longrunning operation. More information
6624        /// on [delete_management_dns_zone_binding][crate::client::VmwareEngine::delete_management_dns_zone_binding].
6625        pub async fn send(self) -> Result<longrunning::model::Operation> {
6626            (*self.0.stub)
6627                .delete_management_dns_zone_binding(self.0.request, self.0.options)
6628                .await
6629                .map(gax::response::Response::into_body)
6630        }
6631
6632        /// Creates a [Poller][lro::Poller] to work with `delete_management_dns_zone_binding`.
6633        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
6634            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
6635            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
6636            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
6637
6638            let stub = self.0.stub.clone();
6639            let mut options = self.0.options.clone();
6640            options.set_retry_policy(gax::retry_policy::NeverRetry);
6641            let query = move |name| {
6642                let stub = stub.clone();
6643                let options = options.clone();
6644                async {
6645                    let op = GetOperation::new(stub)
6646                        .set_name(name)
6647                        .with_options(options)
6648                        .send()
6649                        .await?;
6650                    Ok(Operation::new(op))
6651                }
6652            };
6653
6654            let start = move || async {
6655                let op = self.send().await?;
6656                Ok(Operation::new(op))
6657            };
6658
6659            lro::internal::new_unit_response_poller(
6660                polling_error_policy,
6661                polling_backoff_policy,
6662                start,
6663                query,
6664            )
6665        }
6666
6667        /// Sets the value of [name][crate::model::DeleteManagementDnsZoneBindingRequest::name].
6668        ///
6669        /// This is a **required** field for requests.
6670        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
6671            self.0.request.name = v.into();
6672            self
6673        }
6674
6675        /// Sets the value of [request_id][crate::model::DeleteManagementDnsZoneBindingRequest::request_id].
6676        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
6677            self.0.request.request_id = v.into();
6678            self
6679        }
6680    }
6681
6682    #[doc(hidden)]
6683    impl gax::options::internal::RequestBuilder for DeleteManagementDnsZoneBinding {
6684        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
6685            &mut self.0.options
6686        }
6687    }
6688
6689    /// The request builder for [VmwareEngine::repair_management_dns_zone_binding][crate::client::VmwareEngine::repair_management_dns_zone_binding] calls.
6690    ///
6691    /// # Example
6692    /// ```
6693    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::RepairManagementDnsZoneBinding;
6694    /// # async fn sample() -> gax::Result<()> {
6695    /// use lro::Poller;
6696    ///
6697    /// let builder = prepare_request_builder();
6698    /// let response = builder.poller().until_done().await?;
6699    /// # Ok(()) }
6700    ///
6701    /// fn prepare_request_builder() -> RepairManagementDnsZoneBinding {
6702    ///   # panic!();
6703    ///   // ... details omitted ...
6704    /// }
6705    /// ```
6706    #[derive(Clone, Debug)]
6707    pub struct RepairManagementDnsZoneBinding(
6708        RequestBuilder<crate::model::RepairManagementDnsZoneBindingRequest>,
6709    );
6710
6711    impl RepairManagementDnsZoneBinding {
6712        pub(crate) fn new(
6713            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
6714        ) -> Self {
6715            Self(RequestBuilder::new(stub))
6716        }
6717
6718        /// Sets the full request, replacing any prior values.
6719        pub fn with_request<V: Into<crate::model::RepairManagementDnsZoneBindingRequest>>(
6720            mut self,
6721            v: V,
6722        ) -> Self {
6723            self.0.request = v.into();
6724            self
6725        }
6726
6727        /// Sets all the options, replacing any prior values.
6728        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6729            self.0.options = v.into();
6730            self
6731        }
6732
6733        /// Sends the request.
6734        ///
6735        /// # Long running operations
6736        ///
6737        /// This starts, but does not poll, a longrunning operation. More information
6738        /// on [repair_management_dns_zone_binding][crate::client::VmwareEngine::repair_management_dns_zone_binding].
6739        pub async fn send(self) -> Result<longrunning::model::Operation> {
6740            (*self.0.stub)
6741                .repair_management_dns_zone_binding(self.0.request, self.0.options)
6742                .await
6743                .map(gax::response::Response::into_body)
6744        }
6745
6746        /// Creates a [Poller][lro::Poller] to work with `repair_management_dns_zone_binding`.
6747        pub fn poller(
6748            self,
6749        ) -> impl lro::Poller<crate::model::ManagementDnsZoneBinding, crate::model::OperationMetadata>
6750        {
6751            type Operation = lro::internal::Operation<
6752                crate::model::ManagementDnsZoneBinding,
6753                crate::model::OperationMetadata,
6754            >;
6755            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
6756            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
6757
6758            let stub = self.0.stub.clone();
6759            let mut options = self.0.options.clone();
6760            options.set_retry_policy(gax::retry_policy::NeverRetry);
6761            let query = move |name| {
6762                let stub = stub.clone();
6763                let options = options.clone();
6764                async {
6765                    let op = GetOperation::new(stub)
6766                        .set_name(name)
6767                        .with_options(options)
6768                        .send()
6769                        .await?;
6770                    Ok(Operation::new(op))
6771                }
6772            };
6773
6774            let start = move || async {
6775                let op = self.send().await?;
6776                Ok(Operation::new(op))
6777            };
6778
6779            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
6780        }
6781
6782        /// Sets the value of [name][crate::model::RepairManagementDnsZoneBindingRequest::name].
6783        ///
6784        /// This is a **required** field for requests.
6785        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
6786            self.0.request.name = v.into();
6787            self
6788        }
6789
6790        /// Sets the value of [request_id][crate::model::RepairManagementDnsZoneBindingRequest::request_id].
6791        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
6792            self.0.request.request_id = v.into();
6793            self
6794        }
6795    }
6796
6797    #[doc(hidden)]
6798    impl gax::options::internal::RequestBuilder for RepairManagementDnsZoneBinding {
6799        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
6800            &mut self.0.options
6801        }
6802    }
6803
6804    /// The request builder for [VmwareEngine::create_vmware_engine_network][crate::client::VmwareEngine::create_vmware_engine_network] calls.
6805    ///
6806    /// # Example
6807    /// ```
6808    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreateVmwareEngineNetwork;
6809    /// # async fn sample() -> gax::Result<()> {
6810    /// use lro::Poller;
6811    ///
6812    /// let builder = prepare_request_builder();
6813    /// let response = builder.poller().until_done().await?;
6814    /// # Ok(()) }
6815    ///
6816    /// fn prepare_request_builder() -> CreateVmwareEngineNetwork {
6817    ///   # panic!();
6818    ///   // ... details omitted ...
6819    /// }
6820    /// ```
6821    #[derive(Clone, Debug)]
6822    pub struct CreateVmwareEngineNetwork(
6823        RequestBuilder<crate::model::CreateVmwareEngineNetworkRequest>,
6824    );
6825
6826    impl CreateVmwareEngineNetwork {
6827        pub(crate) fn new(
6828            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
6829        ) -> Self {
6830            Self(RequestBuilder::new(stub))
6831        }
6832
6833        /// Sets the full request, replacing any prior values.
6834        pub fn with_request<V: Into<crate::model::CreateVmwareEngineNetworkRequest>>(
6835            mut self,
6836            v: V,
6837        ) -> Self {
6838            self.0.request = v.into();
6839            self
6840        }
6841
6842        /// Sets all the options, replacing any prior values.
6843        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6844            self.0.options = v.into();
6845            self
6846        }
6847
6848        /// Sends the request.
6849        ///
6850        /// # Long running operations
6851        ///
6852        /// This starts, but does not poll, a longrunning operation. More information
6853        /// on [create_vmware_engine_network][crate::client::VmwareEngine::create_vmware_engine_network].
6854        pub async fn send(self) -> Result<longrunning::model::Operation> {
6855            (*self.0.stub)
6856                .create_vmware_engine_network(self.0.request, self.0.options)
6857                .await
6858                .map(gax::response::Response::into_body)
6859        }
6860
6861        /// Creates a [Poller][lro::Poller] to work with `create_vmware_engine_network`.
6862        pub fn poller(
6863            self,
6864        ) -> impl lro::Poller<crate::model::VmwareEngineNetwork, crate::model::OperationMetadata>
6865        {
6866            type Operation = lro::internal::Operation<
6867                crate::model::VmwareEngineNetwork,
6868                crate::model::OperationMetadata,
6869            >;
6870            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
6871            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
6872
6873            let stub = self.0.stub.clone();
6874            let mut options = self.0.options.clone();
6875            options.set_retry_policy(gax::retry_policy::NeverRetry);
6876            let query = move |name| {
6877                let stub = stub.clone();
6878                let options = options.clone();
6879                async {
6880                    let op = GetOperation::new(stub)
6881                        .set_name(name)
6882                        .with_options(options)
6883                        .send()
6884                        .await?;
6885                    Ok(Operation::new(op))
6886                }
6887            };
6888
6889            let start = move || async {
6890                let op = self.send().await?;
6891                Ok(Operation::new(op))
6892            };
6893
6894            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
6895        }
6896
6897        /// Sets the value of [parent][crate::model::CreateVmwareEngineNetworkRequest::parent].
6898        ///
6899        /// This is a **required** field for requests.
6900        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
6901            self.0.request.parent = v.into();
6902            self
6903        }
6904
6905        /// Sets the value of [vmware_engine_network_id][crate::model::CreateVmwareEngineNetworkRequest::vmware_engine_network_id].
6906        ///
6907        /// This is a **required** field for requests.
6908        pub fn set_vmware_engine_network_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
6909            self.0.request.vmware_engine_network_id = v.into();
6910            self
6911        }
6912
6913        /// Sets the value of [vmware_engine_network][crate::model::CreateVmwareEngineNetworkRequest::vmware_engine_network].
6914        ///
6915        /// This is a **required** field for requests.
6916        pub fn set_vmware_engine_network<T>(mut self, v: T) -> Self
6917        where
6918            T: std::convert::Into<crate::model::VmwareEngineNetwork>,
6919        {
6920            self.0.request.vmware_engine_network = std::option::Option::Some(v.into());
6921            self
6922        }
6923
6924        /// Sets or clears the value of [vmware_engine_network][crate::model::CreateVmwareEngineNetworkRequest::vmware_engine_network].
6925        ///
6926        /// This is a **required** field for requests.
6927        pub fn set_or_clear_vmware_engine_network<T>(mut self, v: std::option::Option<T>) -> Self
6928        where
6929            T: std::convert::Into<crate::model::VmwareEngineNetwork>,
6930        {
6931            self.0.request.vmware_engine_network = v.map(|x| x.into());
6932            self
6933        }
6934
6935        /// Sets the value of [request_id][crate::model::CreateVmwareEngineNetworkRequest::request_id].
6936        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
6937            self.0.request.request_id = v.into();
6938            self
6939        }
6940    }
6941
6942    #[doc(hidden)]
6943    impl gax::options::internal::RequestBuilder for CreateVmwareEngineNetwork {
6944        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
6945            &mut self.0.options
6946        }
6947    }
6948
6949    /// The request builder for [VmwareEngine::update_vmware_engine_network][crate::client::VmwareEngine::update_vmware_engine_network] calls.
6950    ///
6951    /// # Example
6952    /// ```
6953    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdateVmwareEngineNetwork;
6954    /// # async fn sample() -> gax::Result<()> {
6955    /// use lro::Poller;
6956    ///
6957    /// let builder = prepare_request_builder();
6958    /// let response = builder.poller().until_done().await?;
6959    /// # Ok(()) }
6960    ///
6961    /// fn prepare_request_builder() -> UpdateVmwareEngineNetwork {
6962    ///   # panic!();
6963    ///   // ... details omitted ...
6964    /// }
6965    /// ```
6966    #[derive(Clone, Debug)]
6967    pub struct UpdateVmwareEngineNetwork(
6968        RequestBuilder<crate::model::UpdateVmwareEngineNetworkRequest>,
6969    );
6970
6971    impl UpdateVmwareEngineNetwork {
6972        pub(crate) fn new(
6973            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
6974        ) -> Self {
6975            Self(RequestBuilder::new(stub))
6976        }
6977
6978        /// Sets the full request, replacing any prior values.
6979        pub fn with_request<V: Into<crate::model::UpdateVmwareEngineNetworkRequest>>(
6980            mut self,
6981            v: V,
6982        ) -> Self {
6983            self.0.request = v.into();
6984            self
6985        }
6986
6987        /// Sets all the options, replacing any prior values.
6988        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
6989            self.0.options = v.into();
6990            self
6991        }
6992
6993        /// Sends the request.
6994        ///
6995        /// # Long running operations
6996        ///
6997        /// This starts, but does not poll, a longrunning operation. More information
6998        /// on [update_vmware_engine_network][crate::client::VmwareEngine::update_vmware_engine_network].
6999        pub async fn send(self) -> Result<longrunning::model::Operation> {
7000            (*self.0.stub)
7001                .update_vmware_engine_network(self.0.request, self.0.options)
7002                .await
7003                .map(gax::response::Response::into_body)
7004        }
7005
7006        /// Creates a [Poller][lro::Poller] to work with `update_vmware_engine_network`.
7007        pub fn poller(
7008            self,
7009        ) -> impl lro::Poller<crate::model::VmwareEngineNetwork, crate::model::OperationMetadata>
7010        {
7011            type Operation = lro::internal::Operation<
7012                crate::model::VmwareEngineNetwork,
7013                crate::model::OperationMetadata,
7014            >;
7015            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
7016            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
7017
7018            let stub = self.0.stub.clone();
7019            let mut options = self.0.options.clone();
7020            options.set_retry_policy(gax::retry_policy::NeverRetry);
7021            let query = move |name| {
7022                let stub = stub.clone();
7023                let options = options.clone();
7024                async {
7025                    let op = GetOperation::new(stub)
7026                        .set_name(name)
7027                        .with_options(options)
7028                        .send()
7029                        .await?;
7030                    Ok(Operation::new(op))
7031                }
7032            };
7033
7034            let start = move || async {
7035                let op = self.send().await?;
7036                Ok(Operation::new(op))
7037            };
7038
7039            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
7040        }
7041
7042        /// Sets the value of [vmware_engine_network][crate::model::UpdateVmwareEngineNetworkRequest::vmware_engine_network].
7043        ///
7044        /// This is a **required** field for requests.
7045        pub fn set_vmware_engine_network<T>(mut self, v: T) -> Self
7046        where
7047            T: std::convert::Into<crate::model::VmwareEngineNetwork>,
7048        {
7049            self.0.request.vmware_engine_network = std::option::Option::Some(v.into());
7050            self
7051        }
7052
7053        /// Sets or clears the value of [vmware_engine_network][crate::model::UpdateVmwareEngineNetworkRequest::vmware_engine_network].
7054        ///
7055        /// This is a **required** field for requests.
7056        pub fn set_or_clear_vmware_engine_network<T>(mut self, v: std::option::Option<T>) -> Self
7057        where
7058            T: std::convert::Into<crate::model::VmwareEngineNetwork>,
7059        {
7060            self.0.request.vmware_engine_network = v.map(|x| x.into());
7061            self
7062        }
7063
7064        /// Sets the value of [update_mask][crate::model::UpdateVmwareEngineNetworkRequest::update_mask].
7065        ///
7066        /// This is a **required** field for requests.
7067        pub fn set_update_mask<T>(mut self, v: T) -> Self
7068        where
7069            T: std::convert::Into<wkt::FieldMask>,
7070        {
7071            self.0.request.update_mask = std::option::Option::Some(v.into());
7072            self
7073        }
7074
7075        /// Sets or clears the value of [update_mask][crate::model::UpdateVmwareEngineNetworkRequest::update_mask].
7076        ///
7077        /// This is a **required** field for requests.
7078        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
7079        where
7080            T: std::convert::Into<wkt::FieldMask>,
7081        {
7082            self.0.request.update_mask = v.map(|x| x.into());
7083            self
7084        }
7085
7086        /// Sets the value of [request_id][crate::model::UpdateVmwareEngineNetworkRequest::request_id].
7087        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
7088            self.0.request.request_id = v.into();
7089            self
7090        }
7091    }
7092
7093    #[doc(hidden)]
7094    impl gax::options::internal::RequestBuilder for UpdateVmwareEngineNetwork {
7095        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
7096            &mut self.0.options
7097        }
7098    }
7099
7100    /// The request builder for [VmwareEngine::delete_vmware_engine_network][crate::client::VmwareEngine::delete_vmware_engine_network] calls.
7101    ///
7102    /// # Example
7103    /// ```
7104    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteVmwareEngineNetwork;
7105    /// # async fn sample() -> gax::Result<()> {
7106    /// use lro::Poller;
7107    ///
7108    /// let builder = prepare_request_builder();
7109    /// let response = builder.poller().until_done().await?;
7110    /// # Ok(()) }
7111    ///
7112    /// fn prepare_request_builder() -> DeleteVmwareEngineNetwork {
7113    ///   # panic!();
7114    ///   // ... details omitted ...
7115    /// }
7116    /// ```
7117    #[derive(Clone, Debug)]
7118    pub struct DeleteVmwareEngineNetwork(
7119        RequestBuilder<crate::model::DeleteVmwareEngineNetworkRequest>,
7120    );
7121
7122    impl DeleteVmwareEngineNetwork {
7123        pub(crate) fn new(
7124            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
7125        ) -> Self {
7126            Self(RequestBuilder::new(stub))
7127        }
7128
7129        /// Sets the full request, replacing any prior values.
7130        pub fn with_request<V: Into<crate::model::DeleteVmwareEngineNetworkRequest>>(
7131            mut self,
7132            v: V,
7133        ) -> Self {
7134            self.0.request = v.into();
7135            self
7136        }
7137
7138        /// Sets all the options, replacing any prior values.
7139        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
7140            self.0.options = v.into();
7141            self
7142        }
7143
7144        /// Sends the request.
7145        ///
7146        /// # Long running operations
7147        ///
7148        /// This starts, but does not poll, a longrunning operation. More information
7149        /// on [delete_vmware_engine_network][crate::client::VmwareEngine::delete_vmware_engine_network].
7150        pub async fn send(self) -> Result<longrunning::model::Operation> {
7151            (*self.0.stub)
7152                .delete_vmware_engine_network(self.0.request, self.0.options)
7153                .await
7154                .map(gax::response::Response::into_body)
7155        }
7156
7157        /// Creates a [Poller][lro::Poller] to work with `delete_vmware_engine_network`.
7158        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
7159            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
7160            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
7161            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
7162
7163            let stub = self.0.stub.clone();
7164            let mut options = self.0.options.clone();
7165            options.set_retry_policy(gax::retry_policy::NeverRetry);
7166            let query = move |name| {
7167                let stub = stub.clone();
7168                let options = options.clone();
7169                async {
7170                    let op = GetOperation::new(stub)
7171                        .set_name(name)
7172                        .with_options(options)
7173                        .send()
7174                        .await?;
7175                    Ok(Operation::new(op))
7176                }
7177            };
7178
7179            let start = move || async {
7180                let op = self.send().await?;
7181                Ok(Operation::new(op))
7182            };
7183
7184            lro::internal::new_unit_response_poller(
7185                polling_error_policy,
7186                polling_backoff_policy,
7187                start,
7188                query,
7189            )
7190        }
7191
7192        /// Sets the value of [name][crate::model::DeleteVmwareEngineNetworkRequest::name].
7193        ///
7194        /// This is a **required** field for requests.
7195        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
7196            self.0.request.name = v.into();
7197            self
7198        }
7199
7200        /// Sets the value of [request_id][crate::model::DeleteVmwareEngineNetworkRequest::request_id].
7201        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
7202            self.0.request.request_id = v.into();
7203            self
7204        }
7205
7206        /// Sets the value of [etag][crate::model::DeleteVmwareEngineNetworkRequest::etag].
7207        pub fn set_etag<T: Into<std::string::String>>(mut self, v: T) -> Self {
7208            self.0.request.etag = v.into();
7209            self
7210        }
7211    }
7212
7213    #[doc(hidden)]
7214    impl gax::options::internal::RequestBuilder for DeleteVmwareEngineNetwork {
7215        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
7216            &mut self.0.options
7217        }
7218    }
7219
7220    /// The request builder for [VmwareEngine::get_vmware_engine_network][crate::client::VmwareEngine::get_vmware_engine_network] calls.
7221    ///
7222    /// # Example
7223    /// ```
7224    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetVmwareEngineNetwork;
7225    /// # async fn sample() -> gax::Result<()> {
7226    ///
7227    /// let builder = prepare_request_builder();
7228    /// let response = builder.send().await?;
7229    /// # Ok(()) }
7230    ///
7231    /// fn prepare_request_builder() -> GetVmwareEngineNetwork {
7232    ///   # panic!();
7233    ///   // ... details omitted ...
7234    /// }
7235    /// ```
7236    #[derive(Clone, Debug)]
7237    pub struct GetVmwareEngineNetwork(RequestBuilder<crate::model::GetVmwareEngineNetworkRequest>);
7238
7239    impl GetVmwareEngineNetwork {
7240        pub(crate) fn new(
7241            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
7242        ) -> Self {
7243            Self(RequestBuilder::new(stub))
7244        }
7245
7246        /// Sets the full request, replacing any prior values.
7247        pub fn with_request<V: Into<crate::model::GetVmwareEngineNetworkRequest>>(
7248            mut self,
7249            v: V,
7250        ) -> Self {
7251            self.0.request = v.into();
7252            self
7253        }
7254
7255        /// Sets all the options, replacing any prior values.
7256        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
7257            self.0.options = v.into();
7258            self
7259        }
7260
7261        /// Sends the request.
7262        pub async fn send(self) -> Result<crate::model::VmwareEngineNetwork> {
7263            (*self.0.stub)
7264                .get_vmware_engine_network(self.0.request, self.0.options)
7265                .await
7266                .map(gax::response::Response::into_body)
7267        }
7268
7269        /// Sets the value of [name][crate::model::GetVmwareEngineNetworkRequest::name].
7270        ///
7271        /// This is a **required** field for requests.
7272        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
7273            self.0.request.name = v.into();
7274            self
7275        }
7276    }
7277
7278    #[doc(hidden)]
7279    impl gax::options::internal::RequestBuilder for GetVmwareEngineNetwork {
7280        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
7281            &mut self.0.options
7282        }
7283    }
7284
7285    /// The request builder for [VmwareEngine::list_vmware_engine_networks][crate::client::VmwareEngine::list_vmware_engine_networks] calls.
7286    ///
7287    /// # Example
7288    /// ```
7289    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListVmwareEngineNetworks;
7290    /// # async fn sample() -> gax::Result<()> {
7291    /// use gax::paginator::ItemPaginator;
7292    ///
7293    /// let builder = prepare_request_builder();
7294    /// let mut items = builder.by_item();
7295    /// while let Some(result) = items.next().await {
7296    ///   let item = result?;
7297    /// }
7298    /// # Ok(()) }
7299    ///
7300    /// fn prepare_request_builder() -> ListVmwareEngineNetworks {
7301    ///   # panic!();
7302    ///   // ... details omitted ...
7303    /// }
7304    /// ```
7305    #[derive(Clone, Debug)]
7306    pub struct ListVmwareEngineNetworks(
7307        RequestBuilder<crate::model::ListVmwareEngineNetworksRequest>,
7308    );
7309
7310    impl ListVmwareEngineNetworks {
7311        pub(crate) fn new(
7312            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
7313        ) -> Self {
7314            Self(RequestBuilder::new(stub))
7315        }
7316
7317        /// Sets the full request, replacing any prior values.
7318        pub fn with_request<V: Into<crate::model::ListVmwareEngineNetworksRequest>>(
7319            mut self,
7320            v: V,
7321        ) -> Self {
7322            self.0.request = v.into();
7323            self
7324        }
7325
7326        /// Sets all the options, replacing any prior values.
7327        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
7328            self.0.options = v.into();
7329            self
7330        }
7331
7332        /// Sends the request.
7333        pub async fn send(self) -> Result<crate::model::ListVmwareEngineNetworksResponse> {
7334            (*self.0.stub)
7335                .list_vmware_engine_networks(self.0.request, self.0.options)
7336                .await
7337                .map(gax::response::Response::into_body)
7338        }
7339
7340        /// Streams each page in the collection.
7341        pub fn by_page(
7342            self,
7343        ) -> impl gax::paginator::Paginator<
7344            crate::model::ListVmwareEngineNetworksResponse,
7345            gax::error::Error,
7346        > {
7347            use std::clone::Clone;
7348            let token = self.0.request.page_token.clone();
7349            let execute = move |token: String| {
7350                let mut builder = self.clone();
7351                builder.0.request = builder.0.request.set_page_token(token);
7352                builder.send()
7353            };
7354            gax::paginator::internal::new_paginator(token, execute)
7355        }
7356
7357        /// Streams each item in the collection.
7358        pub fn by_item(
7359            self,
7360        ) -> impl gax::paginator::ItemPaginator<
7361            crate::model::ListVmwareEngineNetworksResponse,
7362            gax::error::Error,
7363        > {
7364            use gax::paginator::Paginator;
7365            self.by_page().items()
7366        }
7367
7368        /// Sets the value of [parent][crate::model::ListVmwareEngineNetworksRequest::parent].
7369        ///
7370        /// This is a **required** field for requests.
7371        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
7372            self.0.request.parent = v.into();
7373            self
7374        }
7375
7376        /// Sets the value of [page_size][crate::model::ListVmwareEngineNetworksRequest::page_size].
7377        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
7378            self.0.request.page_size = v.into();
7379            self
7380        }
7381
7382        /// Sets the value of [page_token][crate::model::ListVmwareEngineNetworksRequest::page_token].
7383        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
7384            self.0.request.page_token = v.into();
7385            self
7386        }
7387
7388        /// Sets the value of [filter][crate::model::ListVmwareEngineNetworksRequest::filter].
7389        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
7390            self.0.request.filter = v.into();
7391            self
7392        }
7393
7394        /// Sets the value of [order_by][crate::model::ListVmwareEngineNetworksRequest::order_by].
7395        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
7396            self.0.request.order_by = v.into();
7397            self
7398        }
7399    }
7400
7401    #[doc(hidden)]
7402    impl gax::options::internal::RequestBuilder for ListVmwareEngineNetworks {
7403        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
7404            &mut self.0.options
7405        }
7406    }
7407
7408    /// The request builder for [VmwareEngine::create_private_connection][crate::client::VmwareEngine::create_private_connection] calls.
7409    ///
7410    /// # Example
7411    /// ```
7412    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::CreatePrivateConnection;
7413    /// # async fn sample() -> gax::Result<()> {
7414    /// use lro::Poller;
7415    ///
7416    /// let builder = prepare_request_builder();
7417    /// let response = builder.poller().until_done().await?;
7418    /// # Ok(()) }
7419    ///
7420    /// fn prepare_request_builder() -> CreatePrivateConnection {
7421    ///   # panic!();
7422    ///   // ... details omitted ...
7423    /// }
7424    /// ```
7425    #[derive(Clone, Debug)]
7426    pub struct CreatePrivateConnection(
7427        RequestBuilder<crate::model::CreatePrivateConnectionRequest>,
7428    );
7429
7430    impl CreatePrivateConnection {
7431        pub(crate) fn new(
7432            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
7433        ) -> Self {
7434            Self(RequestBuilder::new(stub))
7435        }
7436
7437        /// Sets the full request, replacing any prior values.
7438        pub fn with_request<V: Into<crate::model::CreatePrivateConnectionRequest>>(
7439            mut self,
7440            v: V,
7441        ) -> Self {
7442            self.0.request = v.into();
7443            self
7444        }
7445
7446        /// Sets all the options, replacing any prior values.
7447        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
7448            self.0.options = v.into();
7449            self
7450        }
7451
7452        /// Sends the request.
7453        ///
7454        /// # Long running operations
7455        ///
7456        /// This starts, but does not poll, a longrunning operation. More information
7457        /// on [create_private_connection][crate::client::VmwareEngine::create_private_connection].
7458        pub async fn send(self) -> Result<longrunning::model::Operation> {
7459            (*self.0.stub)
7460                .create_private_connection(self.0.request, self.0.options)
7461                .await
7462                .map(gax::response::Response::into_body)
7463        }
7464
7465        /// Creates a [Poller][lro::Poller] to work with `create_private_connection`.
7466        pub fn poller(
7467            self,
7468        ) -> impl lro::Poller<crate::model::PrivateConnection, crate::model::OperationMetadata>
7469        {
7470            type Operation = lro::internal::Operation<
7471                crate::model::PrivateConnection,
7472                crate::model::OperationMetadata,
7473            >;
7474            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
7475            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
7476
7477            let stub = self.0.stub.clone();
7478            let mut options = self.0.options.clone();
7479            options.set_retry_policy(gax::retry_policy::NeverRetry);
7480            let query = move |name| {
7481                let stub = stub.clone();
7482                let options = options.clone();
7483                async {
7484                    let op = GetOperation::new(stub)
7485                        .set_name(name)
7486                        .with_options(options)
7487                        .send()
7488                        .await?;
7489                    Ok(Operation::new(op))
7490                }
7491            };
7492
7493            let start = move || async {
7494                let op = self.send().await?;
7495                Ok(Operation::new(op))
7496            };
7497
7498            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
7499        }
7500
7501        /// Sets the value of [parent][crate::model::CreatePrivateConnectionRequest::parent].
7502        ///
7503        /// This is a **required** field for requests.
7504        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
7505            self.0.request.parent = v.into();
7506            self
7507        }
7508
7509        /// Sets the value of [private_connection_id][crate::model::CreatePrivateConnectionRequest::private_connection_id].
7510        ///
7511        /// This is a **required** field for requests.
7512        pub fn set_private_connection_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
7513            self.0.request.private_connection_id = v.into();
7514            self
7515        }
7516
7517        /// Sets the value of [private_connection][crate::model::CreatePrivateConnectionRequest::private_connection].
7518        ///
7519        /// This is a **required** field for requests.
7520        pub fn set_private_connection<T>(mut self, v: T) -> Self
7521        where
7522            T: std::convert::Into<crate::model::PrivateConnection>,
7523        {
7524            self.0.request.private_connection = std::option::Option::Some(v.into());
7525            self
7526        }
7527
7528        /// Sets or clears the value of [private_connection][crate::model::CreatePrivateConnectionRequest::private_connection].
7529        ///
7530        /// This is a **required** field for requests.
7531        pub fn set_or_clear_private_connection<T>(mut self, v: std::option::Option<T>) -> Self
7532        where
7533            T: std::convert::Into<crate::model::PrivateConnection>,
7534        {
7535            self.0.request.private_connection = v.map(|x| x.into());
7536            self
7537        }
7538
7539        /// Sets the value of [request_id][crate::model::CreatePrivateConnectionRequest::request_id].
7540        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
7541            self.0.request.request_id = v.into();
7542            self
7543        }
7544    }
7545
7546    #[doc(hidden)]
7547    impl gax::options::internal::RequestBuilder for CreatePrivateConnection {
7548        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
7549            &mut self.0.options
7550        }
7551    }
7552
7553    /// The request builder for [VmwareEngine::get_private_connection][crate::client::VmwareEngine::get_private_connection] calls.
7554    ///
7555    /// # Example
7556    /// ```
7557    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetPrivateConnection;
7558    /// # async fn sample() -> gax::Result<()> {
7559    ///
7560    /// let builder = prepare_request_builder();
7561    /// let response = builder.send().await?;
7562    /// # Ok(()) }
7563    ///
7564    /// fn prepare_request_builder() -> GetPrivateConnection {
7565    ///   # panic!();
7566    ///   // ... details omitted ...
7567    /// }
7568    /// ```
7569    #[derive(Clone, Debug)]
7570    pub struct GetPrivateConnection(RequestBuilder<crate::model::GetPrivateConnectionRequest>);
7571
7572    impl GetPrivateConnection {
7573        pub(crate) fn new(
7574            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
7575        ) -> Self {
7576            Self(RequestBuilder::new(stub))
7577        }
7578
7579        /// Sets the full request, replacing any prior values.
7580        pub fn with_request<V: Into<crate::model::GetPrivateConnectionRequest>>(
7581            mut self,
7582            v: V,
7583        ) -> Self {
7584            self.0.request = v.into();
7585            self
7586        }
7587
7588        /// Sets all the options, replacing any prior values.
7589        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
7590            self.0.options = v.into();
7591            self
7592        }
7593
7594        /// Sends the request.
7595        pub async fn send(self) -> Result<crate::model::PrivateConnection> {
7596            (*self.0.stub)
7597                .get_private_connection(self.0.request, self.0.options)
7598                .await
7599                .map(gax::response::Response::into_body)
7600        }
7601
7602        /// Sets the value of [name][crate::model::GetPrivateConnectionRequest::name].
7603        ///
7604        /// This is a **required** field for requests.
7605        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
7606            self.0.request.name = v.into();
7607            self
7608        }
7609    }
7610
7611    #[doc(hidden)]
7612    impl gax::options::internal::RequestBuilder for GetPrivateConnection {
7613        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
7614            &mut self.0.options
7615        }
7616    }
7617
7618    /// The request builder for [VmwareEngine::list_private_connections][crate::client::VmwareEngine::list_private_connections] calls.
7619    ///
7620    /// # Example
7621    /// ```
7622    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListPrivateConnections;
7623    /// # async fn sample() -> gax::Result<()> {
7624    /// use gax::paginator::ItemPaginator;
7625    ///
7626    /// let builder = prepare_request_builder();
7627    /// let mut items = builder.by_item();
7628    /// while let Some(result) = items.next().await {
7629    ///   let item = result?;
7630    /// }
7631    /// # Ok(()) }
7632    ///
7633    /// fn prepare_request_builder() -> ListPrivateConnections {
7634    ///   # panic!();
7635    ///   // ... details omitted ...
7636    /// }
7637    /// ```
7638    #[derive(Clone, Debug)]
7639    pub struct ListPrivateConnections(RequestBuilder<crate::model::ListPrivateConnectionsRequest>);
7640
7641    impl ListPrivateConnections {
7642        pub(crate) fn new(
7643            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
7644        ) -> Self {
7645            Self(RequestBuilder::new(stub))
7646        }
7647
7648        /// Sets the full request, replacing any prior values.
7649        pub fn with_request<V: Into<crate::model::ListPrivateConnectionsRequest>>(
7650            mut self,
7651            v: V,
7652        ) -> Self {
7653            self.0.request = v.into();
7654            self
7655        }
7656
7657        /// Sets all the options, replacing any prior values.
7658        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
7659            self.0.options = v.into();
7660            self
7661        }
7662
7663        /// Sends the request.
7664        pub async fn send(self) -> Result<crate::model::ListPrivateConnectionsResponse> {
7665            (*self.0.stub)
7666                .list_private_connections(self.0.request, self.0.options)
7667                .await
7668                .map(gax::response::Response::into_body)
7669        }
7670
7671        /// Streams each page in the collection.
7672        pub fn by_page(
7673            self,
7674        ) -> impl gax::paginator::Paginator<
7675            crate::model::ListPrivateConnectionsResponse,
7676            gax::error::Error,
7677        > {
7678            use std::clone::Clone;
7679            let token = self.0.request.page_token.clone();
7680            let execute = move |token: String| {
7681                let mut builder = self.clone();
7682                builder.0.request = builder.0.request.set_page_token(token);
7683                builder.send()
7684            };
7685            gax::paginator::internal::new_paginator(token, execute)
7686        }
7687
7688        /// Streams each item in the collection.
7689        pub fn by_item(
7690            self,
7691        ) -> impl gax::paginator::ItemPaginator<
7692            crate::model::ListPrivateConnectionsResponse,
7693            gax::error::Error,
7694        > {
7695            use gax::paginator::Paginator;
7696            self.by_page().items()
7697        }
7698
7699        /// Sets the value of [parent][crate::model::ListPrivateConnectionsRequest::parent].
7700        ///
7701        /// This is a **required** field for requests.
7702        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
7703            self.0.request.parent = v.into();
7704            self
7705        }
7706
7707        /// Sets the value of [page_size][crate::model::ListPrivateConnectionsRequest::page_size].
7708        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
7709            self.0.request.page_size = v.into();
7710            self
7711        }
7712
7713        /// Sets the value of [page_token][crate::model::ListPrivateConnectionsRequest::page_token].
7714        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
7715            self.0.request.page_token = v.into();
7716            self
7717        }
7718
7719        /// Sets the value of [filter][crate::model::ListPrivateConnectionsRequest::filter].
7720        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
7721            self.0.request.filter = v.into();
7722            self
7723        }
7724
7725        /// Sets the value of [order_by][crate::model::ListPrivateConnectionsRequest::order_by].
7726        pub fn set_order_by<T: Into<std::string::String>>(mut self, v: T) -> Self {
7727            self.0.request.order_by = v.into();
7728            self
7729        }
7730    }
7731
7732    #[doc(hidden)]
7733    impl gax::options::internal::RequestBuilder for ListPrivateConnections {
7734        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
7735            &mut self.0.options
7736        }
7737    }
7738
7739    /// The request builder for [VmwareEngine::update_private_connection][crate::client::VmwareEngine::update_private_connection] calls.
7740    ///
7741    /// # Example
7742    /// ```
7743    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::UpdatePrivateConnection;
7744    /// # async fn sample() -> gax::Result<()> {
7745    /// use lro::Poller;
7746    ///
7747    /// let builder = prepare_request_builder();
7748    /// let response = builder.poller().until_done().await?;
7749    /// # Ok(()) }
7750    ///
7751    /// fn prepare_request_builder() -> UpdatePrivateConnection {
7752    ///   # panic!();
7753    ///   // ... details omitted ...
7754    /// }
7755    /// ```
7756    #[derive(Clone, Debug)]
7757    pub struct UpdatePrivateConnection(
7758        RequestBuilder<crate::model::UpdatePrivateConnectionRequest>,
7759    );
7760
7761    impl UpdatePrivateConnection {
7762        pub(crate) fn new(
7763            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
7764        ) -> Self {
7765            Self(RequestBuilder::new(stub))
7766        }
7767
7768        /// Sets the full request, replacing any prior values.
7769        pub fn with_request<V: Into<crate::model::UpdatePrivateConnectionRequest>>(
7770            mut self,
7771            v: V,
7772        ) -> Self {
7773            self.0.request = v.into();
7774            self
7775        }
7776
7777        /// Sets all the options, replacing any prior values.
7778        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
7779            self.0.options = v.into();
7780            self
7781        }
7782
7783        /// Sends the request.
7784        ///
7785        /// # Long running operations
7786        ///
7787        /// This starts, but does not poll, a longrunning operation. More information
7788        /// on [update_private_connection][crate::client::VmwareEngine::update_private_connection].
7789        pub async fn send(self) -> Result<longrunning::model::Operation> {
7790            (*self.0.stub)
7791                .update_private_connection(self.0.request, self.0.options)
7792                .await
7793                .map(gax::response::Response::into_body)
7794        }
7795
7796        /// Creates a [Poller][lro::Poller] to work with `update_private_connection`.
7797        pub fn poller(
7798            self,
7799        ) -> impl lro::Poller<crate::model::PrivateConnection, crate::model::OperationMetadata>
7800        {
7801            type Operation = lro::internal::Operation<
7802                crate::model::PrivateConnection,
7803                crate::model::OperationMetadata,
7804            >;
7805            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
7806            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
7807
7808            let stub = self.0.stub.clone();
7809            let mut options = self.0.options.clone();
7810            options.set_retry_policy(gax::retry_policy::NeverRetry);
7811            let query = move |name| {
7812                let stub = stub.clone();
7813                let options = options.clone();
7814                async {
7815                    let op = GetOperation::new(stub)
7816                        .set_name(name)
7817                        .with_options(options)
7818                        .send()
7819                        .await?;
7820                    Ok(Operation::new(op))
7821                }
7822            };
7823
7824            let start = move || async {
7825                let op = self.send().await?;
7826                Ok(Operation::new(op))
7827            };
7828
7829            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
7830        }
7831
7832        /// Sets the value of [private_connection][crate::model::UpdatePrivateConnectionRequest::private_connection].
7833        ///
7834        /// This is a **required** field for requests.
7835        pub fn set_private_connection<T>(mut self, v: T) -> Self
7836        where
7837            T: std::convert::Into<crate::model::PrivateConnection>,
7838        {
7839            self.0.request.private_connection = std::option::Option::Some(v.into());
7840            self
7841        }
7842
7843        /// Sets or clears the value of [private_connection][crate::model::UpdatePrivateConnectionRequest::private_connection].
7844        ///
7845        /// This is a **required** field for requests.
7846        pub fn set_or_clear_private_connection<T>(mut self, v: std::option::Option<T>) -> Self
7847        where
7848            T: std::convert::Into<crate::model::PrivateConnection>,
7849        {
7850            self.0.request.private_connection = v.map(|x| x.into());
7851            self
7852        }
7853
7854        /// Sets the value of [update_mask][crate::model::UpdatePrivateConnectionRequest::update_mask].
7855        ///
7856        /// This is a **required** field for requests.
7857        pub fn set_update_mask<T>(mut self, v: T) -> Self
7858        where
7859            T: std::convert::Into<wkt::FieldMask>,
7860        {
7861            self.0.request.update_mask = std::option::Option::Some(v.into());
7862            self
7863        }
7864
7865        /// Sets or clears the value of [update_mask][crate::model::UpdatePrivateConnectionRequest::update_mask].
7866        ///
7867        /// This is a **required** field for requests.
7868        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
7869        where
7870            T: std::convert::Into<wkt::FieldMask>,
7871        {
7872            self.0.request.update_mask = v.map(|x| x.into());
7873            self
7874        }
7875
7876        /// Sets the value of [request_id][crate::model::UpdatePrivateConnectionRequest::request_id].
7877        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
7878            self.0.request.request_id = v.into();
7879            self
7880        }
7881    }
7882
7883    #[doc(hidden)]
7884    impl gax::options::internal::RequestBuilder for UpdatePrivateConnection {
7885        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
7886            &mut self.0.options
7887        }
7888    }
7889
7890    /// The request builder for [VmwareEngine::delete_private_connection][crate::client::VmwareEngine::delete_private_connection] calls.
7891    ///
7892    /// # Example
7893    /// ```
7894    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeletePrivateConnection;
7895    /// # async fn sample() -> gax::Result<()> {
7896    /// use lro::Poller;
7897    ///
7898    /// let builder = prepare_request_builder();
7899    /// let response = builder.poller().until_done().await?;
7900    /// # Ok(()) }
7901    ///
7902    /// fn prepare_request_builder() -> DeletePrivateConnection {
7903    ///   # panic!();
7904    ///   // ... details omitted ...
7905    /// }
7906    /// ```
7907    #[derive(Clone, Debug)]
7908    pub struct DeletePrivateConnection(
7909        RequestBuilder<crate::model::DeletePrivateConnectionRequest>,
7910    );
7911
7912    impl DeletePrivateConnection {
7913        pub(crate) fn new(
7914            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
7915        ) -> Self {
7916            Self(RequestBuilder::new(stub))
7917        }
7918
7919        /// Sets the full request, replacing any prior values.
7920        pub fn with_request<V: Into<crate::model::DeletePrivateConnectionRequest>>(
7921            mut self,
7922            v: V,
7923        ) -> Self {
7924            self.0.request = v.into();
7925            self
7926        }
7927
7928        /// Sets all the options, replacing any prior values.
7929        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
7930            self.0.options = v.into();
7931            self
7932        }
7933
7934        /// Sends the request.
7935        ///
7936        /// # Long running operations
7937        ///
7938        /// This starts, but does not poll, a longrunning operation. More information
7939        /// on [delete_private_connection][crate::client::VmwareEngine::delete_private_connection].
7940        pub async fn send(self) -> Result<longrunning::model::Operation> {
7941            (*self.0.stub)
7942                .delete_private_connection(self.0.request, self.0.options)
7943                .await
7944                .map(gax::response::Response::into_body)
7945        }
7946
7947        /// Creates a [Poller][lro::Poller] to work with `delete_private_connection`.
7948        pub fn poller(self) -> impl lro::Poller<(), crate::model::OperationMetadata> {
7949            type Operation = lro::internal::Operation<wkt::Empty, crate::model::OperationMetadata>;
7950            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
7951            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
7952
7953            let stub = self.0.stub.clone();
7954            let mut options = self.0.options.clone();
7955            options.set_retry_policy(gax::retry_policy::NeverRetry);
7956            let query = move |name| {
7957                let stub = stub.clone();
7958                let options = options.clone();
7959                async {
7960                    let op = GetOperation::new(stub)
7961                        .set_name(name)
7962                        .with_options(options)
7963                        .send()
7964                        .await?;
7965                    Ok(Operation::new(op))
7966                }
7967            };
7968
7969            let start = move || async {
7970                let op = self.send().await?;
7971                Ok(Operation::new(op))
7972            };
7973
7974            lro::internal::new_unit_response_poller(
7975                polling_error_policy,
7976                polling_backoff_policy,
7977                start,
7978                query,
7979            )
7980        }
7981
7982        /// Sets the value of [name][crate::model::DeletePrivateConnectionRequest::name].
7983        ///
7984        /// This is a **required** field for requests.
7985        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
7986            self.0.request.name = v.into();
7987            self
7988        }
7989
7990        /// Sets the value of [request_id][crate::model::DeletePrivateConnectionRequest::request_id].
7991        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
7992            self.0.request.request_id = v.into();
7993            self
7994        }
7995    }
7996
7997    #[doc(hidden)]
7998    impl gax::options::internal::RequestBuilder for DeletePrivateConnection {
7999        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8000            &mut self.0.options
8001        }
8002    }
8003
8004    /// The request builder for [VmwareEngine::list_private_connection_peering_routes][crate::client::VmwareEngine::list_private_connection_peering_routes] calls.
8005    ///
8006    /// # Example
8007    /// ```
8008    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListPrivateConnectionPeeringRoutes;
8009    /// # async fn sample() -> gax::Result<()> {
8010    /// use gax::paginator::ItemPaginator;
8011    ///
8012    /// let builder = prepare_request_builder();
8013    /// let mut items = builder.by_item();
8014    /// while let Some(result) = items.next().await {
8015    ///   let item = result?;
8016    /// }
8017    /// # Ok(()) }
8018    ///
8019    /// fn prepare_request_builder() -> ListPrivateConnectionPeeringRoutes {
8020    ///   # panic!();
8021    ///   // ... details omitted ...
8022    /// }
8023    /// ```
8024    #[derive(Clone, Debug)]
8025    pub struct ListPrivateConnectionPeeringRoutes(
8026        RequestBuilder<crate::model::ListPrivateConnectionPeeringRoutesRequest>,
8027    );
8028
8029    impl ListPrivateConnectionPeeringRoutes {
8030        pub(crate) fn new(
8031            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8032        ) -> Self {
8033            Self(RequestBuilder::new(stub))
8034        }
8035
8036        /// Sets the full request, replacing any prior values.
8037        pub fn with_request<V: Into<crate::model::ListPrivateConnectionPeeringRoutesRequest>>(
8038            mut self,
8039            v: V,
8040        ) -> Self {
8041            self.0.request = v.into();
8042            self
8043        }
8044
8045        /// Sets all the options, replacing any prior values.
8046        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8047            self.0.options = v.into();
8048            self
8049        }
8050
8051        /// Sends the request.
8052        pub async fn send(
8053            self,
8054        ) -> Result<crate::model::ListPrivateConnectionPeeringRoutesResponse> {
8055            (*self.0.stub)
8056                .list_private_connection_peering_routes(self.0.request, self.0.options)
8057                .await
8058                .map(gax::response::Response::into_body)
8059        }
8060
8061        /// Streams each page in the collection.
8062        pub fn by_page(
8063            self,
8064        ) -> impl gax::paginator::Paginator<
8065            crate::model::ListPrivateConnectionPeeringRoutesResponse,
8066            gax::error::Error,
8067        > {
8068            use std::clone::Clone;
8069            let token = self.0.request.page_token.clone();
8070            let execute = move |token: String| {
8071                let mut builder = self.clone();
8072                builder.0.request = builder.0.request.set_page_token(token);
8073                builder.send()
8074            };
8075            gax::paginator::internal::new_paginator(token, execute)
8076        }
8077
8078        /// Streams each item in the collection.
8079        pub fn by_item(
8080            self,
8081        ) -> impl gax::paginator::ItemPaginator<
8082            crate::model::ListPrivateConnectionPeeringRoutesResponse,
8083            gax::error::Error,
8084        > {
8085            use gax::paginator::Paginator;
8086            self.by_page().items()
8087        }
8088
8089        /// Sets the value of [parent][crate::model::ListPrivateConnectionPeeringRoutesRequest::parent].
8090        ///
8091        /// This is a **required** field for requests.
8092        pub fn set_parent<T: Into<std::string::String>>(mut self, v: T) -> Self {
8093            self.0.request.parent = v.into();
8094            self
8095        }
8096
8097        /// Sets the value of [page_size][crate::model::ListPrivateConnectionPeeringRoutesRequest::page_size].
8098        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
8099            self.0.request.page_size = v.into();
8100            self
8101        }
8102
8103        /// Sets the value of [page_token][crate::model::ListPrivateConnectionPeeringRoutesRequest::page_token].
8104        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
8105            self.0.request.page_token = v.into();
8106            self
8107        }
8108    }
8109
8110    #[doc(hidden)]
8111    impl gax::options::internal::RequestBuilder for ListPrivateConnectionPeeringRoutes {
8112        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8113            &mut self.0.options
8114        }
8115    }
8116
8117    /// The request builder for [VmwareEngine::grant_dns_bind_permission][crate::client::VmwareEngine::grant_dns_bind_permission] calls.
8118    ///
8119    /// # Example
8120    /// ```
8121    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GrantDnsBindPermission;
8122    /// # async fn sample() -> gax::Result<()> {
8123    /// use lro::Poller;
8124    ///
8125    /// let builder = prepare_request_builder();
8126    /// let response = builder.poller().until_done().await?;
8127    /// # Ok(()) }
8128    ///
8129    /// fn prepare_request_builder() -> GrantDnsBindPermission {
8130    ///   # panic!();
8131    ///   // ... details omitted ...
8132    /// }
8133    /// ```
8134    #[derive(Clone, Debug)]
8135    pub struct GrantDnsBindPermission(RequestBuilder<crate::model::GrantDnsBindPermissionRequest>);
8136
8137    impl GrantDnsBindPermission {
8138        pub(crate) fn new(
8139            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8140        ) -> Self {
8141            Self(RequestBuilder::new(stub))
8142        }
8143
8144        /// Sets the full request, replacing any prior values.
8145        pub fn with_request<V: Into<crate::model::GrantDnsBindPermissionRequest>>(
8146            mut self,
8147            v: V,
8148        ) -> Self {
8149            self.0.request = v.into();
8150            self
8151        }
8152
8153        /// Sets all the options, replacing any prior values.
8154        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8155            self.0.options = v.into();
8156            self
8157        }
8158
8159        /// Sends the request.
8160        ///
8161        /// # Long running operations
8162        ///
8163        /// This starts, but does not poll, a longrunning operation. More information
8164        /// on [grant_dns_bind_permission][crate::client::VmwareEngine::grant_dns_bind_permission].
8165        pub async fn send(self) -> Result<longrunning::model::Operation> {
8166            (*self.0.stub)
8167                .grant_dns_bind_permission(self.0.request, self.0.options)
8168                .await
8169                .map(gax::response::Response::into_body)
8170        }
8171
8172        /// Creates a [Poller][lro::Poller] to work with `grant_dns_bind_permission`.
8173        pub fn poller(
8174            self,
8175        ) -> impl lro::Poller<crate::model::DnsBindPermission, crate::model::OperationMetadata>
8176        {
8177            type Operation = lro::internal::Operation<
8178                crate::model::DnsBindPermission,
8179                crate::model::OperationMetadata,
8180            >;
8181            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
8182            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
8183
8184            let stub = self.0.stub.clone();
8185            let mut options = self.0.options.clone();
8186            options.set_retry_policy(gax::retry_policy::NeverRetry);
8187            let query = move |name| {
8188                let stub = stub.clone();
8189                let options = options.clone();
8190                async {
8191                    let op = GetOperation::new(stub)
8192                        .set_name(name)
8193                        .with_options(options)
8194                        .send()
8195                        .await?;
8196                    Ok(Operation::new(op))
8197                }
8198            };
8199
8200            let start = move || async {
8201                let op = self.send().await?;
8202                Ok(Operation::new(op))
8203            };
8204
8205            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
8206        }
8207
8208        /// Sets the value of [name][crate::model::GrantDnsBindPermissionRequest::name].
8209        ///
8210        /// This is a **required** field for requests.
8211        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
8212            self.0.request.name = v.into();
8213            self
8214        }
8215
8216        /// Sets the value of [principal][crate::model::GrantDnsBindPermissionRequest::principal].
8217        ///
8218        /// This is a **required** field for requests.
8219        pub fn set_principal<T>(mut self, v: T) -> Self
8220        where
8221            T: std::convert::Into<crate::model::Principal>,
8222        {
8223            self.0.request.principal = std::option::Option::Some(v.into());
8224            self
8225        }
8226
8227        /// Sets or clears the value of [principal][crate::model::GrantDnsBindPermissionRequest::principal].
8228        ///
8229        /// This is a **required** field for requests.
8230        pub fn set_or_clear_principal<T>(mut self, v: std::option::Option<T>) -> Self
8231        where
8232            T: std::convert::Into<crate::model::Principal>,
8233        {
8234            self.0.request.principal = v.map(|x| x.into());
8235            self
8236        }
8237
8238        /// Sets the value of [request_id][crate::model::GrantDnsBindPermissionRequest::request_id].
8239        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
8240            self.0.request.request_id = v.into();
8241            self
8242        }
8243    }
8244
8245    #[doc(hidden)]
8246    impl gax::options::internal::RequestBuilder for GrantDnsBindPermission {
8247        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8248            &mut self.0.options
8249        }
8250    }
8251
8252    /// The request builder for [VmwareEngine::get_dns_bind_permission][crate::client::VmwareEngine::get_dns_bind_permission] calls.
8253    ///
8254    /// # Example
8255    /// ```
8256    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetDnsBindPermission;
8257    /// # async fn sample() -> gax::Result<()> {
8258    ///
8259    /// let builder = prepare_request_builder();
8260    /// let response = builder.send().await?;
8261    /// # Ok(()) }
8262    ///
8263    /// fn prepare_request_builder() -> GetDnsBindPermission {
8264    ///   # panic!();
8265    ///   // ... details omitted ...
8266    /// }
8267    /// ```
8268    #[derive(Clone, Debug)]
8269    pub struct GetDnsBindPermission(RequestBuilder<crate::model::GetDnsBindPermissionRequest>);
8270
8271    impl GetDnsBindPermission {
8272        pub(crate) fn new(
8273            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8274        ) -> Self {
8275            Self(RequestBuilder::new(stub))
8276        }
8277
8278        /// Sets the full request, replacing any prior values.
8279        pub fn with_request<V: Into<crate::model::GetDnsBindPermissionRequest>>(
8280            mut self,
8281            v: V,
8282        ) -> Self {
8283            self.0.request = v.into();
8284            self
8285        }
8286
8287        /// Sets all the options, replacing any prior values.
8288        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8289            self.0.options = v.into();
8290            self
8291        }
8292
8293        /// Sends the request.
8294        pub async fn send(self) -> Result<crate::model::DnsBindPermission> {
8295            (*self.0.stub)
8296                .get_dns_bind_permission(self.0.request, self.0.options)
8297                .await
8298                .map(gax::response::Response::into_body)
8299        }
8300
8301        /// Sets the value of [name][crate::model::GetDnsBindPermissionRequest::name].
8302        ///
8303        /// This is a **required** field for requests.
8304        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
8305            self.0.request.name = v.into();
8306            self
8307        }
8308    }
8309
8310    #[doc(hidden)]
8311    impl gax::options::internal::RequestBuilder for GetDnsBindPermission {
8312        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8313            &mut self.0.options
8314        }
8315    }
8316
8317    /// The request builder for [VmwareEngine::revoke_dns_bind_permission][crate::client::VmwareEngine::revoke_dns_bind_permission] calls.
8318    ///
8319    /// # Example
8320    /// ```
8321    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::RevokeDnsBindPermission;
8322    /// # async fn sample() -> gax::Result<()> {
8323    /// use lro::Poller;
8324    ///
8325    /// let builder = prepare_request_builder();
8326    /// let response = builder.poller().until_done().await?;
8327    /// # Ok(()) }
8328    ///
8329    /// fn prepare_request_builder() -> RevokeDnsBindPermission {
8330    ///   # panic!();
8331    ///   // ... details omitted ...
8332    /// }
8333    /// ```
8334    #[derive(Clone, Debug)]
8335    pub struct RevokeDnsBindPermission(
8336        RequestBuilder<crate::model::RevokeDnsBindPermissionRequest>,
8337    );
8338
8339    impl RevokeDnsBindPermission {
8340        pub(crate) fn new(
8341            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8342        ) -> Self {
8343            Self(RequestBuilder::new(stub))
8344        }
8345
8346        /// Sets the full request, replacing any prior values.
8347        pub fn with_request<V: Into<crate::model::RevokeDnsBindPermissionRequest>>(
8348            mut self,
8349            v: V,
8350        ) -> Self {
8351            self.0.request = v.into();
8352            self
8353        }
8354
8355        /// Sets all the options, replacing any prior values.
8356        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8357            self.0.options = v.into();
8358            self
8359        }
8360
8361        /// Sends the request.
8362        ///
8363        /// # Long running operations
8364        ///
8365        /// This starts, but does not poll, a longrunning operation. More information
8366        /// on [revoke_dns_bind_permission][crate::client::VmwareEngine::revoke_dns_bind_permission].
8367        pub async fn send(self) -> Result<longrunning::model::Operation> {
8368            (*self.0.stub)
8369                .revoke_dns_bind_permission(self.0.request, self.0.options)
8370                .await
8371                .map(gax::response::Response::into_body)
8372        }
8373
8374        /// Creates a [Poller][lro::Poller] to work with `revoke_dns_bind_permission`.
8375        pub fn poller(
8376            self,
8377        ) -> impl lro::Poller<crate::model::DnsBindPermission, crate::model::OperationMetadata>
8378        {
8379            type Operation = lro::internal::Operation<
8380                crate::model::DnsBindPermission,
8381                crate::model::OperationMetadata,
8382            >;
8383            let polling_error_policy = self.0.stub.get_polling_error_policy(&self.0.options);
8384            let polling_backoff_policy = self.0.stub.get_polling_backoff_policy(&self.0.options);
8385
8386            let stub = self.0.stub.clone();
8387            let mut options = self.0.options.clone();
8388            options.set_retry_policy(gax::retry_policy::NeverRetry);
8389            let query = move |name| {
8390                let stub = stub.clone();
8391                let options = options.clone();
8392                async {
8393                    let op = GetOperation::new(stub)
8394                        .set_name(name)
8395                        .with_options(options)
8396                        .send()
8397                        .await?;
8398                    Ok(Operation::new(op))
8399                }
8400            };
8401
8402            let start = move || async {
8403                let op = self.send().await?;
8404                Ok(Operation::new(op))
8405            };
8406
8407            lro::internal::new_poller(polling_error_policy, polling_backoff_policy, start, query)
8408        }
8409
8410        /// Sets the value of [name][crate::model::RevokeDnsBindPermissionRequest::name].
8411        ///
8412        /// This is a **required** field for requests.
8413        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
8414            self.0.request.name = v.into();
8415            self
8416        }
8417
8418        /// Sets the value of [principal][crate::model::RevokeDnsBindPermissionRequest::principal].
8419        ///
8420        /// This is a **required** field for requests.
8421        pub fn set_principal<T>(mut self, v: T) -> Self
8422        where
8423            T: std::convert::Into<crate::model::Principal>,
8424        {
8425            self.0.request.principal = std::option::Option::Some(v.into());
8426            self
8427        }
8428
8429        /// Sets or clears the value of [principal][crate::model::RevokeDnsBindPermissionRequest::principal].
8430        ///
8431        /// This is a **required** field for requests.
8432        pub fn set_or_clear_principal<T>(mut self, v: std::option::Option<T>) -> Self
8433        where
8434            T: std::convert::Into<crate::model::Principal>,
8435        {
8436            self.0.request.principal = v.map(|x| x.into());
8437            self
8438        }
8439
8440        /// Sets the value of [request_id][crate::model::RevokeDnsBindPermissionRequest::request_id].
8441        pub fn set_request_id<T: Into<std::string::String>>(mut self, v: T) -> Self {
8442            self.0.request.request_id = v.into();
8443            self
8444        }
8445    }
8446
8447    #[doc(hidden)]
8448    impl gax::options::internal::RequestBuilder for RevokeDnsBindPermission {
8449        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8450            &mut self.0.options
8451        }
8452    }
8453
8454    /// The request builder for [VmwareEngine::list_locations][crate::client::VmwareEngine::list_locations] calls.
8455    ///
8456    /// # Example
8457    /// ```
8458    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListLocations;
8459    /// # async fn sample() -> gax::Result<()> {
8460    /// use gax::paginator::ItemPaginator;
8461    ///
8462    /// let builder = prepare_request_builder();
8463    /// let mut items = builder.by_item();
8464    /// while let Some(result) = items.next().await {
8465    ///   let item = result?;
8466    /// }
8467    /// # Ok(()) }
8468    ///
8469    /// fn prepare_request_builder() -> ListLocations {
8470    ///   # panic!();
8471    ///   // ... details omitted ...
8472    /// }
8473    /// ```
8474    #[derive(Clone, Debug)]
8475    pub struct ListLocations(RequestBuilder<location::model::ListLocationsRequest>);
8476
8477    impl ListLocations {
8478        pub(crate) fn new(
8479            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8480        ) -> Self {
8481            Self(RequestBuilder::new(stub))
8482        }
8483
8484        /// Sets the full request, replacing any prior values.
8485        pub fn with_request<V: Into<location::model::ListLocationsRequest>>(
8486            mut self,
8487            v: V,
8488        ) -> Self {
8489            self.0.request = v.into();
8490            self
8491        }
8492
8493        /// Sets all the options, replacing any prior values.
8494        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8495            self.0.options = v.into();
8496            self
8497        }
8498
8499        /// Sends the request.
8500        pub async fn send(self) -> Result<location::model::ListLocationsResponse> {
8501            (*self.0.stub)
8502                .list_locations(self.0.request, self.0.options)
8503                .await
8504                .map(gax::response::Response::into_body)
8505        }
8506
8507        /// Streams each page in the collection.
8508        pub fn by_page(
8509            self,
8510        ) -> impl gax::paginator::Paginator<location::model::ListLocationsResponse, gax::error::Error>
8511        {
8512            use std::clone::Clone;
8513            let token = self.0.request.page_token.clone();
8514            let execute = move |token: String| {
8515                let mut builder = self.clone();
8516                builder.0.request = builder.0.request.set_page_token(token);
8517                builder.send()
8518            };
8519            gax::paginator::internal::new_paginator(token, execute)
8520        }
8521
8522        /// Streams each item in the collection.
8523        pub fn by_item(
8524            self,
8525        ) -> impl gax::paginator::ItemPaginator<location::model::ListLocationsResponse, gax::error::Error>
8526        {
8527            use gax::paginator::Paginator;
8528            self.by_page().items()
8529        }
8530
8531        /// Sets the value of [name][location::model::ListLocationsRequest::name].
8532        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
8533            self.0.request.name = v.into();
8534            self
8535        }
8536
8537        /// Sets the value of [filter][location::model::ListLocationsRequest::filter].
8538        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
8539            self.0.request.filter = v.into();
8540            self
8541        }
8542
8543        /// Sets the value of [page_size][location::model::ListLocationsRequest::page_size].
8544        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
8545            self.0.request.page_size = v.into();
8546            self
8547        }
8548
8549        /// Sets the value of [page_token][location::model::ListLocationsRequest::page_token].
8550        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
8551            self.0.request.page_token = v.into();
8552            self
8553        }
8554    }
8555
8556    #[doc(hidden)]
8557    impl gax::options::internal::RequestBuilder for ListLocations {
8558        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8559            &mut self.0.options
8560        }
8561    }
8562
8563    /// The request builder for [VmwareEngine::get_location][crate::client::VmwareEngine::get_location] calls.
8564    ///
8565    /// # Example
8566    /// ```
8567    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetLocation;
8568    /// # async fn sample() -> gax::Result<()> {
8569    ///
8570    /// let builder = prepare_request_builder();
8571    /// let response = builder.send().await?;
8572    /// # Ok(()) }
8573    ///
8574    /// fn prepare_request_builder() -> GetLocation {
8575    ///   # panic!();
8576    ///   // ... details omitted ...
8577    /// }
8578    /// ```
8579    #[derive(Clone, Debug)]
8580    pub struct GetLocation(RequestBuilder<location::model::GetLocationRequest>);
8581
8582    impl GetLocation {
8583        pub(crate) fn new(
8584            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8585        ) -> Self {
8586            Self(RequestBuilder::new(stub))
8587        }
8588
8589        /// Sets the full request, replacing any prior values.
8590        pub fn with_request<V: Into<location::model::GetLocationRequest>>(mut self, v: V) -> Self {
8591            self.0.request = v.into();
8592            self
8593        }
8594
8595        /// Sets all the options, replacing any prior values.
8596        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8597            self.0.options = v.into();
8598            self
8599        }
8600
8601        /// Sends the request.
8602        pub async fn send(self) -> Result<location::model::Location> {
8603            (*self.0.stub)
8604                .get_location(self.0.request, self.0.options)
8605                .await
8606                .map(gax::response::Response::into_body)
8607        }
8608
8609        /// Sets the value of [name][location::model::GetLocationRequest::name].
8610        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
8611            self.0.request.name = v.into();
8612            self
8613        }
8614    }
8615
8616    #[doc(hidden)]
8617    impl gax::options::internal::RequestBuilder for GetLocation {
8618        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8619            &mut self.0.options
8620        }
8621    }
8622
8623    /// The request builder for [VmwareEngine::set_iam_policy][crate::client::VmwareEngine::set_iam_policy] calls.
8624    ///
8625    /// # Example
8626    /// ```
8627    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::SetIamPolicy;
8628    /// # async fn sample() -> gax::Result<()> {
8629    ///
8630    /// let builder = prepare_request_builder();
8631    /// let response = builder.send().await?;
8632    /// # Ok(()) }
8633    ///
8634    /// fn prepare_request_builder() -> SetIamPolicy {
8635    ///   # panic!();
8636    ///   // ... details omitted ...
8637    /// }
8638    /// ```
8639    #[derive(Clone, Debug)]
8640    pub struct SetIamPolicy(RequestBuilder<iam_v1::model::SetIamPolicyRequest>);
8641
8642    impl SetIamPolicy {
8643        pub(crate) fn new(
8644            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8645        ) -> Self {
8646            Self(RequestBuilder::new(stub))
8647        }
8648
8649        /// Sets the full request, replacing any prior values.
8650        pub fn with_request<V: Into<iam_v1::model::SetIamPolicyRequest>>(mut self, v: V) -> Self {
8651            self.0.request = v.into();
8652            self
8653        }
8654
8655        /// Sets all the options, replacing any prior values.
8656        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8657            self.0.options = v.into();
8658            self
8659        }
8660
8661        /// Sends the request.
8662        pub async fn send(self) -> Result<iam_v1::model::Policy> {
8663            (*self.0.stub)
8664                .set_iam_policy(self.0.request, self.0.options)
8665                .await
8666                .map(gax::response::Response::into_body)
8667        }
8668
8669        /// Sets the value of [resource][iam_v1::model::SetIamPolicyRequest::resource].
8670        ///
8671        /// This is a **required** field for requests.
8672        pub fn set_resource<T: Into<std::string::String>>(mut self, v: T) -> Self {
8673            self.0.request.resource = v.into();
8674            self
8675        }
8676
8677        /// Sets the value of [policy][iam_v1::model::SetIamPolicyRequest::policy].
8678        ///
8679        /// This is a **required** field for requests.
8680        pub fn set_policy<T>(mut self, v: T) -> Self
8681        where
8682            T: std::convert::Into<iam_v1::model::Policy>,
8683        {
8684            self.0.request.policy = std::option::Option::Some(v.into());
8685            self
8686        }
8687
8688        /// Sets or clears the value of [policy][iam_v1::model::SetIamPolicyRequest::policy].
8689        ///
8690        /// This is a **required** field for requests.
8691        pub fn set_or_clear_policy<T>(mut self, v: std::option::Option<T>) -> Self
8692        where
8693            T: std::convert::Into<iam_v1::model::Policy>,
8694        {
8695            self.0.request.policy = v.map(|x| x.into());
8696            self
8697        }
8698
8699        /// Sets the value of [update_mask][iam_v1::model::SetIamPolicyRequest::update_mask].
8700        pub fn set_update_mask<T>(mut self, v: T) -> Self
8701        where
8702            T: std::convert::Into<wkt::FieldMask>,
8703        {
8704            self.0.request.update_mask = std::option::Option::Some(v.into());
8705            self
8706        }
8707
8708        /// Sets or clears the value of [update_mask][iam_v1::model::SetIamPolicyRequest::update_mask].
8709        pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
8710        where
8711            T: std::convert::Into<wkt::FieldMask>,
8712        {
8713            self.0.request.update_mask = v.map(|x| x.into());
8714            self
8715        }
8716    }
8717
8718    #[doc(hidden)]
8719    impl gax::options::internal::RequestBuilder for SetIamPolicy {
8720        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8721            &mut self.0.options
8722        }
8723    }
8724
8725    /// The request builder for [VmwareEngine::get_iam_policy][crate::client::VmwareEngine::get_iam_policy] calls.
8726    ///
8727    /// # Example
8728    /// ```
8729    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetIamPolicy;
8730    /// # async fn sample() -> gax::Result<()> {
8731    ///
8732    /// let builder = prepare_request_builder();
8733    /// let response = builder.send().await?;
8734    /// # Ok(()) }
8735    ///
8736    /// fn prepare_request_builder() -> GetIamPolicy {
8737    ///   # panic!();
8738    ///   // ... details omitted ...
8739    /// }
8740    /// ```
8741    #[derive(Clone, Debug)]
8742    pub struct GetIamPolicy(RequestBuilder<iam_v1::model::GetIamPolicyRequest>);
8743
8744    impl GetIamPolicy {
8745        pub(crate) fn new(
8746            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8747        ) -> Self {
8748            Self(RequestBuilder::new(stub))
8749        }
8750
8751        /// Sets the full request, replacing any prior values.
8752        pub fn with_request<V: Into<iam_v1::model::GetIamPolicyRequest>>(mut self, v: V) -> Self {
8753            self.0.request = v.into();
8754            self
8755        }
8756
8757        /// Sets all the options, replacing any prior values.
8758        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8759            self.0.options = v.into();
8760            self
8761        }
8762
8763        /// Sends the request.
8764        pub async fn send(self) -> Result<iam_v1::model::Policy> {
8765            (*self.0.stub)
8766                .get_iam_policy(self.0.request, self.0.options)
8767                .await
8768                .map(gax::response::Response::into_body)
8769        }
8770
8771        /// Sets the value of [resource][iam_v1::model::GetIamPolicyRequest::resource].
8772        ///
8773        /// This is a **required** field for requests.
8774        pub fn set_resource<T: Into<std::string::String>>(mut self, v: T) -> Self {
8775            self.0.request.resource = v.into();
8776            self
8777        }
8778
8779        /// Sets the value of [options][iam_v1::model::GetIamPolicyRequest::options].
8780        pub fn set_options<T>(mut self, v: T) -> Self
8781        where
8782            T: std::convert::Into<iam_v1::model::GetPolicyOptions>,
8783        {
8784            self.0.request.options = std::option::Option::Some(v.into());
8785            self
8786        }
8787
8788        /// Sets or clears the value of [options][iam_v1::model::GetIamPolicyRequest::options].
8789        pub fn set_or_clear_options<T>(mut self, v: std::option::Option<T>) -> Self
8790        where
8791            T: std::convert::Into<iam_v1::model::GetPolicyOptions>,
8792        {
8793            self.0.request.options = v.map(|x| x.into());
8794            self
8795        }
8796    }
8797
8798    #[doc(hidden)]
8799    impl gax::options::internal::RequestBuilder for GetIamPolicy {
8800        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8801            &mut self.0.options
8802        }
8803    }
8804
8805    /// The request builder for [VmwareEngine::test_iam_permissions][crate::client::VmwareEngine::test_iam_permissions] calls.
8806    ///
8807    /// # Example
8808    /// ```
8809    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::TestIamPermissions;
8810    /// # async fn sample() -> gax::Result<()> {
8811    ///
8812    /// let builder = prepare_request_builder();
8813    /// let response = builder.send().await?;
8814    /// # Ok(()) }
8815    ///
8816    /// fn prepare_request_builder() -> TestIamPermissions {
8817    ///   # panic!();
8818    ///   // ... details omitted ...
8819    /// }
8820    /// ```
8821    #[derive(Clone, Debug)]
8822    pub struct TestIamPermissions(RequestBuilder<iam_v1::model::TestIamPermissionsRequest>);
8823
8824    impl TestIamPermissions {
8825        pub(crate) fn new(
8826            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8827        ) -> Self {
8828            Self(RequestBuilder::new(stub))
8829        }
8830
8831        /// Sets the full request, replacing any prior values.
8832        pub fn with_request<V: Into<iam_v1::model::TestIamPermissionsRequest>>(
8833            mut self,
8834            v: V,
8835        ) -> Self {
8836            self.0.request = v.into();
8837            self
8838        }
8839
8840        /// Sets all the options, replacing any prior values.
8841        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8842            self.0.options = v.into();
8843            self
8844        }
8845
8846        /// Sends the request.
8847        pub async fn send(self) -> Result<iam_v1::model::TestIamPermissionsResponse> {
8848            (*self.0.stub)
8849                .test_iam_permissions(self.0.request, self.0.options)
8850                .await
8851                .map(gax::response::Response::into_body)
8852        }
8853
8854        /// Sets the value of [resource][iam_v1::model::TestIamPermissionsRequest::resource].
8855        ///
8856        /// This is a **required** field for requests.
8857        pub fn set_resource<T: Into<std::string::String>>(mut self, v: T) -> Self {
8858            self.0.request.resource = v.into();
8859            self
8860        }
8861
8862        /// Sets the value of [permissions][iam_v1::model::TestIamPermissionsRequest::permissions].
8863        ///
8864        /// This is a **required** field for requests.
8865        pub fn set_permissions<T, V>(mut self, v: T) -> Self
8866        where
8867            T: std::iter::IntoIterator<Item = V>,
8868            V: std::convert::Into<std::string::String>,
8869        {
8870            use std::iter::Iterator;
8871            self.0.request.permissions = v.into_iter().map(|i| i.into()).collect();
8872            self
8873        }
8874    }
8875
8876    #[doc(hidden)]
8877    impl gax::options::internal::RequestBuilder for TestIamPermissions {
8878        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8879            &mut self.0.options
8880        }
8881    }
8882
8883    /// The request builder for [VmwareEngine::list_operations][crate::client::VmwareEngine::list_operations] calls.
8884    ///
8885    /// # Example
8886    /// ```
8887    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::ListOperations;
8888    /// # async fn sample() -> gax::Result<()> {
8889    /// use gax::paginator::ItemPaginator;
8890    ///
8891    /// let builder = prepare_request_builder();
8892    /// let mut items = builder.by_item();
8893    /// while let Some(result) = items.next().await {
8894    ///   let item = result?;
8895    /// }
8896    /// # Ok(()) }
8897    ///
8898    /// fn prepare_request_builder() -> ListOperations {
8899    ///   # panic!();
8900    ///   // ... details omitted ...
8901    /// }
8902    /// ```
8903    #[derive(Clone, Debug)]
8904    pub struct ListOperations(RequestBuilder<longrunning::model::ListOperationsRequest>);
8905
8906    impl ListOperations {
8907        pub(crate) fn new(
8908            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
8909        ) -> Self {
8910            Self(RequestBuilder::new(stub))
8911        }
8912
8913        /// Sets the full request, replacing any prior values.
8914        pub fn with_request<V: Into<longrunning::model::ListOperationsRequest>>(
8915            mut self,
8916            v: V,
8917        ) -> Self {
8918            self.0.request = v.into();
8919            self
8920        }
8921
8922        /// Sets all the options, replacing any prior values.
8923        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
8924            self.0.options = v.into();
8925            self
8926        }
8927
8928        /// Sends the request.
8929        pub async fn send(self) -> Result<longrunning::model::ListOperationsResponse> {
8930            (*self.0.stub)
8931                .list_operations(self.0.request, self.0.options)
8932                .await
8933                .map(gax::response::Response::into_body)
8934        }
8935
8936        /// Streams each page in the collection.
8937        pub fn by_page(
8938            self,
8939        ) -> impl gax::paginator::Paginator<longrunning::model::ListOperationsResponse, gax::error::Error>
8940        {
8941            use std::clone::Clone;
8942            let token = self.0.request.page_token.clone();
8943            let execute = move |token: String| {
8944                let mut builder = self.clone();
8945                builder.0.request = builder.0.request.set_page_token(token);
8946                builder.send()
8947            };
8948            gax::paginator::internal::new_paginator(token, execute)
8949        }
8950
8951        /// Streams each item in the collection.
8952        pub fn by_item(
8953            self,
8954        ) -> impl gax::paginator::ItemPaginator<
8955            longrunning::model::ListOperationsResponse,
8956            gax::error::Error,
8957        > {
8958            use gax::paginator::Paginator;
8959            self.by_page().items()
8960        }
8961
8962        /// Sets the value of [name][longrunning::model::ListOperationsRequest::name].
8963        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
8964            self.0.request.name = v.into();
8965            self
8966        }
8967
8968        /// Sets the value of [filter][longrunning::model::ListOperationsRequest::filter].
8969        pub fn set_filter<T: Into<std::string::String>>(mut self, v: T) -> Self {
8970            self.0.request.filter = v.into();
8971            self
8972        }
8973
8974        /// Sets the value of [page_size][longrunning::model::ListOperationsRequest::page_size].
8975        pub fn set_page_size<T: Into<i32>>(mut self, v: T) -> Self {
8976            self.0.request.page_size = v.into();
8977            self
8978        }
8979
8980        /// Sets the value of [page_token][longrunning::model::ListOperationsRequest::page_token].
8981        pub fn set_page_token<T: Into<std::string::String>>(mut self, v: T) -> Self {
8982            self.0.request.page_token = v.into();
8983            self
8984        }
8985
8986        /// Sets the value of [return_partial_success][longrunning::model::ListOperationsRequest::return_partial_success].
8987        pub fn set_return_partial_success<T: Into<bool>>(mut self, v: T) -> Self {
8988            self.0.request.return_partial_success = v.into();
8989            self
8990        }
8991    }
8992
8993    #[doc(hidden)]
8994    impl gax::options::internal::RequestBuilder for ListOperations {
8995        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
8996            &mut self.0.options
8997        }
8998    }
8999
9000    /// The request builder for [VmwareEngine::get_operation][crate::client::VmwareEngine::get_operation] calls.
9001    ///
9002    /// # Example
9003    /// ```
9004    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::GetOperation;
9005    /// # async fn sample() -> gax::Result<()> {
9006    ///
9007    /// let builder = prepare_request_builder();
9008    /// let response = builder.send().await?;
9009    /// # Ok(()) }
9010    ///
9011    /// fn prepare_request_builder() -> GetOperation {
9012    ///   # panic!();
9013    ///   // ... details omitted ...
9014    /// }
9015    /// ```
9016    #[derive(Clone, Debug)]
9017    pub struct GetOperation(RequestBuilder<longrunning::model::GetOperationRequest>);
9018
9019    impl GetOperation {
9020        pub(crate) fn new(
9021            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
9022        ) -> Self {
9023            Self(RequestBuilder::new(stub))
9024        }
9025
9026        /// Sets the full request, replacing any prior values.
9027        pub fn with_request<V: Into<longrunning::model::GetOperationRequest>>(
9028            mut self,
9029            v: V,
9030        ) -> Self {
9031            self.0.request = v.into();
9032            self
9033        }
9034
9035        /// Sets all the options, replacing any prior values.
9036        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
9037            self.0.options = v.into();
9038            self
9039        }
9040
9041        /// Sends the request.
9042        pub async fn send(self) -> Result<longrunning::model::Operation> {
9043            (*self.0.stub)
9044                .get_operation(self.0.request, self.0.options)
9045                .await
9046                .map(gax::response::Response::into_body)
9047        }
9048
9049        /// Sets the value of [name][longrunning::model::GetOperationRequest::name].
9050        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
9051            self.0.request.name = v.into();
9052            self
9053        }
9054    }
9055
9056    #[doc(hidden)]
9057    impl gax::options::internal::RequestBuilder for GetOperation {
9058        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
9059            &mut self.0.options
9060        }
9061    }
9062
9063    /// The request builder for [VmwareEngine::delete_operation][crate::client::VmwareEngine::delete_operation] calls.
9064    ///
9065    /// # Example
9066    /// ```
9067    /// # use google_cloud_vmwareengine_v1::builder::vmware_engine::DeleteOperation;
9068    /// # async fn sample() -> gax::Result<()> {
9069    ///
9070    /// let builder = prepare_request_builder();
9071    /// let response = builder.send().await?;
9072    /// # Ok(()) }
9073    ///
9074    /// fn prepare_request_builder() -> DeleteOperation {
9075    ///   # panic!();
9076    ///   // ... details omitted ...
9077    /// }
9078    /// ```
9079    #[derive(Clone, Debug)]
9080    pub struct DeleteOperation(RequestBuilder<longrunning::model::DeleteOperationRequest>);
9081
9082    impl DeleteOperation {
9083        pub(crate) fn new(
9084            stub: std::sync::Arc<dyn super::super::stub::dynamic::VmwareEngine>,
9085        ) -> Self {
9086            Self(RequestBuilder::new(stub))
9087        }
9088
9089        /// Sets the full request, replacing any prior values.
9090        pub fn with_request<V: Into<longrunning::model::DeleteOperationRequest>>(
9091            mut self,
9092            v: V,
9093        ) -> Self {
9094            self.0.request = v.into();
9095            self
9096        }
9097
9098        /// Sets all the options, replacing any prior values.
9099        pub fn with_options<V: Into<gax::options::RequestOptions>>(mut self, v: V) -> Self {
9100            self.0.options = v.into();
9101            self
9102        }
9103
9104        /// Sends the request.
9105        pub async fn send(self) -> Result<()> {
9106            (*self.0.stub)
9107                .delete_operation(self.0.request, self.0.options)
9108                .await
9109                .map(gax::response::Response::into_body)
9110        }
9111
9112        /// Sets the value of [name][longrunning::model::DeleteOperationRequest::name].
9113        pub fn set_name<T: Into<std::string::String>>(mut self, v: T) -> Self {
9114            self.0.request.name = v.into();
9115            self
9116        }
9117    }
9118
9119    #[doc(hidden)]
9120    impl gax::options::internal::RequestBuilder for DeleteOperation {
9121        fn request_options(&mut self) -> &mut gax::options::RequestOptions {
9122            &mut self.0.options
9123        }
9124    }
9125}
google_cloud_vmwareengine_v1/builder.rs

google_cloud_vmwareengine_v1/
builder.rs
