google_cloud_privilegedaccessmanager_v1/client.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#![allow(rustdoc::redundant_explicit_links)]
17#![allow(rustdoc::broken_intra_doc_links)]
18
19/// Implements a client for the Privileged Access Manager API.
20///
21/// # Example
22/// ```
23/// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
24/// use google_cloud_gax::paginator::ItemPaginator as _;
25/// # async fn sample() -> Result<(), Box<dyn std::error::Error>> {
26/// let client = PrivilegedAccessManager::builder().build().await?;
27/// let parent = "parent_value";
28/// let mut list = client.list_entitlements()
29/// .set_parent(parent)
30/// .by_item();
31/// while let Some(item) = list.next().await.transpose()? {
32/// println!("{:?}", item);
33/// }
34/// # Ok(()) }
35/// ```
36///
37/// # Service Description
38///
39/// This API allows customers to manage temporary, request based privileged
40/// access to their resources.
41///
42/// It defines the following resource model:
43///
44/// * A collection of `Entitlement` resources. An entitlement allows configuring
45/// (among other things):
46///
47/// * Some kind of privileged access that users can request.
48/// * A set of users called _requesters_ who can request this access.
49/// * A maximum duration for which the access can be requested.
50/// * An optional approval workflow which must be satisfied before access is
51/// granted.
52/// * A collection of `Grant` resources. A grant is a request by a requester to
53/// get the privileged access specified in an entitlement for some duration.
54///
55/// After the approval workflow as specified in the entitlement is satisfied,
56/// the specified access is given to the requester. The access is automatically
57/// taken back after the requested duration is over.
58///
59///
60/// # Configuration
61///
62/// To configure `PrivilegedAccessManager` use the `with_*` methods in the type returned
63/// by [builder()][PrivilegedAccessManager::builder]. The default configuration should
64/// work for most applications. Common configuration changes include
65///
66/// * [with_endpoint()]: by default this client uses the global default endpoint
67/// (`https://privilegedaccessmanager.googleapis.com`). Applications using regional
68/// endpoints or running in restricted networks (e.g. a network configured
69// with [Private Google Access with VPC Service Controls]) may want to
70/// override this default.
71/// * [with_credentials()]: by default this client uses
72/// [Application Default Credentials]. Applications using custom
73/// authentication may need to override this default.
74///
75/// [with_endpoint()]: super::builder::privileged_access_manager::ClientBuilder::with_endpoint
76/// [with_credentials()]: super::builder::privileged_access_manager::ClientBuilder::with_credentials
77/// [Private Google Access with VPC Service Controls]: https://cloud.google.com/vpc-service-controls/docs/private-connectivity
78/// [Application Default Credentials]: https://cloud.google.com/docs/authentication#adc
79///
80/// # Pooling and Cloning
81///
82/// `PrivilegedAccessManager` holds a connection pool internally, it is advised to
83/// create one and reuse it. You do not need to wrap `PrivilegedAccessManager` in
84/// an [Rc](std::rc::Rc) or [Arc](std::sync::Arc) to reuse it, because it
85/// already uses an `Arc` internally.
86#[derive(Clone, Debug)]
87pub struct PrivilegedAccessManager {
88 inner: std::sync::Arc<dyn super::stub::dynamic::PrivilegedAccessManager>,
89}
90
91impl PrivilegedAccessManager {
92 /// Returns a builder for [PrivilegedAccessManager].
93 ///
94 /// ```
95 /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
96 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
97 /// let client = PrivilegedAccessManager::builder().build().await?;
98 /// # Ok(()) }
99 /// ```
100 pub fn builder() -> super::builder::privileged_access_manager::ClientBuilder {
101 crate::new_client_builder(super::builder::privileged_access_manager::client::Factory)
102 }
103
104 /// Creates a new client from the provided stub.
105 ///
106 /// The most common case for calling this function is in tests mocking the
107 /// client's behavior.
108 pub fn from_stub<T>(stub: T) -> Self
109 where
110 T: super::stub::PrivilegedAccessManager + 'static,
111 {
112 Self {
113 inner: std::sync::Arc::new(stub),
114 }
115 }
116
117 pub(crate) async fn new(
118 config: gaxi::options::ClientConfig,
119 ) -> crate::ClientBuilderResult<Self> {
120 let inner = Self::build_inner(config).await?;
121 Ok(Self { inner })
122 }
123
124 async fn build_inner(
125 conf: gaxi::options::ClientConfig,
126 ) -> crate::ClientBuilderResult<std::sync::Arc<dyn super::stub::dynamic::PrivilegedAccessManager>>
127 {
128 if gaxi::options::tracing_enabled(&conf) {
129 return Ok(std::sync::Arc::new(Self::build_with_tracing(conf).await?));
130 }
131 Ok(std::sync::Arc::new(Self::build_transport(conf).await?))
132 }
133
134 async fn build_transport(
135 conf: gaxi::options::ClientConfig,
136 ) -> crate::ClientBuilderResult<impl super::stub::PrivilegedAccessManager> {
137 super::transport::PrivilegedAccessManager::new(conf).await
138 }
139
140 async fn build_with_tracing(
141 conf: gaxi::options::ClientConfig,
142 ) -> crate::ClientBuilderResult<impl super::stub::PrivilegedAccessManager> {
143 Self::build_transport(conf)
144 .await
145 .map(super::tracing::PrivilegedAccessManager::new)
146 }
147
148 /// `CheckOnboardingStatus` reports the onboarding status for a
149 /// project/folder/organization. Any findings reported by this API need to be
150 /// fixed before PAM can be used on the resource.
151 ///
152 /// # Example
153 /// ```
154 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
155 /// use google_cloud_privilegedaccessmanager_v1::Result;
156 /// async fn sample(
157 /// client: &PrivilegedAccessManager
158 /// ) -> Result<()> {
159 /// let response = client.check_onboarding_status()
160 /// /* set fields */
161 /// .send().await?;
162 /// println!("response {:?}", response);
163 /// Ok(())
164 /// }
165 /// ```
166 pub fn check_onboarding_status(
167 &self,
168 ) -> super::builder::privileged_access_manager::CheckOnboardingStatus {
169 super::builder::privileged_access_manager::CheckOnboardingStatus::new(self.inner.clone())
170 }
171
172 /// Lists entitlements in a given project/folder/organization and location.
173 ///
174 /// # Example
175 /// ```
176 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
177 /// use google_cloud_gax::paginator::ItemPaginator as _;
178 /// use google_cloud_privilegedaccessmanager_v1::Result;
179 /// async fn sample(
180 /// client: &PrivilegedAccessManager, parent: &str
181 /// ) -> Result<()> {
182 /// let mut list = client.list_entitlements()
183 /// .set_parent(parent)
184 /// .by_item();
185 /// while let Some(item) = list.next().await.transpose()? {
186 /// println!("{:?}", item);
187 /// }
188 /// Ok(())
189 /// }
190 /// ```
191 pub fn list_entitlements(&self) -> super::builder::privileged_access_manager::ListEntitlements {
192 super::builder::privileged_access_manager::ListEntitlements::new(self.inner.clone())
193 }
194
195 /// `SearchEntitlements` returns entitlements on which the caller has the
196 /// specified access.
197 ///
198 /// # Example
199 /// ```
200 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
201 /// use google_cloud_gax::paginator::ItemPaginator as _;
202 /// use google_cloud_privilegedaccessmanager_v1::Result;
203 /// async fn sample(
204 /// client: &PrivilegedAccessManager
205 /// ) -> Result<()> {
206 /// let mut list = client.search_entitlements()
207 /// /* set fields */
208 /// .by_item();
209 /// while let Some(item) = list.next().await.transpose()? {
210 /// println!("{:?}", item);
211 /// }
212 /// Ok(())
213 /// }
214 /// ```
215 pub fn search_entitlements(
216 &self,
217 ) -> super::builder::privileged_access_manager::SearchEntitlements {
218 super::builder::privileged_access_manager::SearchEntitlements::new(self.inner.clone())
219 }
220
221 /// Gets details of a single entitlement.
222 ///
223 /// # Example
224 /// ```
225 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
226 /// use google_cloud_privilegedaccessmanager_v1::Result;
227 /// async fn sample(
228 /// client: &PrivilegedAccessManager, name: &str
229 /// ) -> Result<()> {
230 /// let response = client.get_entitlement()
231 /// .set_name(name)
232 /// .send().await?;
233 /// println!("response {:?}", response);
234 /// Ok(())
235 /// }
236 /// ```
237 pub fn get_entitlement(&self) -> super::builder::privileged_access_manager::GetEntitlement {
238 super::builder::privileged_access_manager::GetEntitlement::new(self.inner.clone())
239 }
240
241 /// Creates a new entitlement in a given project/folder/organization and
242 /// location.
243 ///
244 /// # Long running operations
245 ///
246 /// This method is used to start, and/or poll a [long-running Operation].
247 /// The [Working with long-running operations] chapter in the [user guide]
248 /// covers these operations in detail.
249 ///
250 /// [long-running operation]: https://google.aip.dev/151
251 /// [user guide]: https://googleapis.github.io/google-cloud-rust/
252 /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
253 ///
254 /// # Example
255 /// ```
256 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
257 /// use google_cloud_lro::Poller;
258 /// use google_cloud_privilegedaccessmanager_v1::model::Entitlement;
259 /// use google_cloud_privilegedaccessmanager_v1::Result;
260 /// async fn sample(
261 /// client: &PrivilegedAccessManager, parent: &str
262 /// ) -> Result<()> {
263 /// let response = client.create_entitlement()
264 /// .set_parent(parent)
265 /// .set_entitlement_id("entitlement_id_value")
266 /// .set_entitlement(
267 /// Entitlement::new()/* set fields */
268 /// )
269 /// .poller().until_done().await?;
270 /// println!("response {:?}", response);
271 /// Ok(())
272 /// }
273 /// ```
274 pub fn create_entitlement(
275 &self,
276 ) -> super::builder::privileged_access_manager::CreateEntitlement {
277 super::builder::privileged_access_manager::CreateEntitlement::new(self.inner.clone())
278 }
279
280 /// Deletes a single entitlement. This method can only be called when there
281 /// are no in-progress (`ACTIVE`/`ACTIVATING`/`REVOKING`) grants under the
282 /// entitlement.
283 ///
284 /// # Long running operations
285 ///
286 /// This method is used to start, and/or poll a [long-running Operation].
287 /// The [Working with long-running operations] chapter in the [user guide]
288 /// covers these operations in detail.
289 ///
290 /// [long-running operation]: https://google.aip.dev/151
291 /// [user guide]: https://googleapis.github.io/google-cloud-rust/
292 /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
293 ///
294 /// # Example
295 /// ```
296 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
297 /// use google_cloud_lro::Poller;
298 /// use google_cloud_privilegedaccessmanager_v1::Result;
299 /// async fn sample(
300 /// client: &PrivilegedAccessManager, name: &str
301 /// ) -> Result<()> {
302 /// let response = client.delete_entitlement()
303 /// .set_name(name)
304 /// .poller().until_done().await?;
305 /// println!("response {:?}", response);
306 /// Ok(())
307 /// }
308 /// ```
309 pub fn delete_entitlement(
310 &self,
311 ) -> super::builder::privileged_access_manager::DeleteEntitlement {
312 super::builder::privileged_access_manager::DeleteEntitlement::new(self.inner.clone())
313 }
314
315 /// Updates the entitlement specified in the request. Updated fields in the
316 /// entitlement need to be specified in an update mask. The changes made to an
317 /// entitlement are applicable only on future grants of the entitlement.
318 /// However, if new approvers are added or existing approvers are removed from
319 /// the approval workflow, the changes are effective on existing grants.
320 ///
321 /// The following fields are not supported for updates:
322 ///
323 /// * All immutable fields
324 /// * Entitlement name
325 /// * Resource name
326 /// * Resource type
327 /// * Adding an approval workflow in an entitlement which previously had no
328 /// approval workflow.
329 /// * Deleting the approval workflow from an entitlement.
330 /// * Adding or deleting a step in the approval workflow (only one step is
331 /// supported)
332 ///
333 /// Note that updates are allowed on the list of approvers in an approval
334 /// workflow step.
335 ///
336 /// # Long running operations
337 ///
338 /// This method is used to start, and/or poll a [long-running Operation].
339 /// The [Working with long-running operations] chapter in the [user guide]
340 /// covers these operations in detail.
341 ///
342 /// [long-running operation]: https://google.aip.dev/151
343 /// [user guide]: https://googleapis.github.io/google-cloud-rust/
344 /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
345 ///
346 /// # Example
347 /// ```
348 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
349 /// use google_cloud_lro::Poller;
350 /// # extern crate wkt as google_cloud_wkt;
351 /// use google_cloud_wkt::FieldMask;
352 /// use google_cloud_privilegedaccessmanager_v1::model::Entitlement;
353 /// use google_cloud_privilegedaccessmanager_v1::Result;
354 /// async fn sample(
355 /// client: &PrivilegedAccessManager, name: &str
356 /// ) -> Result<()> {
357 /// let response = client.update_entitlement()
358 /// .set_entitlement(
359 /// Entitlement::new().set_name(name)/* set fields */
360 /// )
361 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
362 /// .poller().until_done().await?;
363 /// println!("response {:?}", response);
364 /// Ok(())
365 /// }
366 /// ```
367 pub fn update_entitlement(
368 &self,
369 ) -> super::builder::privileged_access_manager::UpdateEntitlement {
370 super::builder::privileged_access_manager::UpdateEntitlement::new(self.inner.clone())
371 }
372
373 /// Lists grants for a given entitlement.
374 ///
375 /// # Example
376 /// ```
377 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
378 /// use google_cloud_gax::paginator::ItemPaginator as _;
379 /// use google_cloud_privilegedaccessmanager_v1::Result;
380 /// async fn sample(
381 /// client: &PrivilegedAccessManager, parent: &str
382 /// ) -> Result<()> {
383 /// let mut list = client.list_grants()
384 /// .set_parent(parent)
385 /// .by_item();
386 /// while let Some(item) = list.next().await.transpose()? {
387 /// println!("{:?}", item);
388 /// }
389 /// Ok(())
390 /// }
391 /// ```
392 pub fn list_grants(&self) -> super::builder::privileged_access_manager::ListGrants {
393 super::builder::privileged_access_manager::ListGrants::new(self.inner.clone())
394 }
395
396 /// `SearchGrants` returns grants that are related to the calling user in the
397 /// specified way.
398 ///
399 /// # Example
400 /// ```
401 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
402 /// use google_cloud_gax::paginator::ItemPaginator as _;
403 /// use google_cloud_privilegedaccessmanager_v1::Result;
404 /// async fn sample(
405 /// client: &PrivilegedAccessManager
406 /// ) -> Result<()> {
407 /// let mut list = client.search_grants()
408 /// /* set fields */
409 /// .by_item();
410 /// while let Some(item) = list.next().await.transpose()? {
411 /// println!("{:?}", item);
412 /// }
413 /// Ok(())
414 /// }
415 /// ```
416 pub fn search_grants(&self) -> super::builder::privileged_access_manager::SearchGrants {
417 super::builder::privileged_access_manager::SearchGrants::new(self.inner.clone())
418 }
419
420 /// Get details of a single grant.
421 ///
422 /// # Example
423 /// ```
424 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
425 /// use google_cloud_privilegedaccessmanager_v1::Result;
426 /// async fn sample(
427 /// client: &PrivilegedAccessManager, name: &str
428 /// ) -> Result<()> {
429 /// let response = client.get_grant()
430 /// .set_name(name)
431 /// .send().await?;
432 /// println!("response {:?}", response);
433 /// Ok(())
434 /// }
435 /// ```
436 pub fn get_grant(&self) -> super::builder::privileged_access_manager::GetGrant {
437 super::builder::privileged_access_manager::GetGrant::new(self.inner.clone())
438 }
439
440 /// Creates a new grant in a given project/folder/organization and
441 /// location.
442 ///
443 /// # Example
444 /// ```
445 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
446 /// use google_cloud_privilegedaccessmanager_v1::model::Grant;
447 /// use google_cloud_privilegedaccessmanager_v1::Result;
448 /// async fn sample(
449 /// client: &PrivilegedAccessManager, parent: &str
450 /// ) -> Result<()> {
451 /// let response = client.create_grant()
452 /// .set_parent(parent)
453 /// .set_grant(
454 /// Grant::new()/* set fields */
455 /// )
456 /// .send().await?;
457 /// println!("response {:?}", response);
458 /// Ok(())
459 /// }
460 /// ```
461 pub fn create_grant(&self) -> super::builder::privileged_access_manager::CreateGrant {
462 super::builder::privileged_access_manager::CreateGrant::new(self.inner.clone())
463 }
464
465 /// `ApproveGrant` is used to approve a grant. This method can only be called
466 /// on a grant when it's in the `APPROVAL_AWAITED` state. This operation can't
467 /// be undone.
468 ///
469 /// # Example
470 /// ```
471 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
472 /// use google_cloud_privilegedaccessmanager_v1::Result;
473 /// async fn sample(
474 /// client: &PrivilegedAccessManager
475 /// ) -> Result<()> {
476 /// let response = client.approve_grant()
477 /// /* set fields */
478 /// .send().await?;
479 /// println!("response {:?}", response);
480 /// Ok(())
481 /// }
482 /// ```
483 pub fn approve_grant(&self) -> super::builder::privileged_access_manager::ApproveGrant {
484 super::builder::privileged_access_manager::ApproveGrant::new(self.inner.clone())
485 }
486
487 /// `DenyGrant` is used to deny a grant. This method can only be called on a
488 /// grant when it's in the `APPROVAL_AWAITED` state. This operation can't be
489 /// undone.
490 ///
491 /// # Example
492 /// ```
493 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
494 /// use google_cloud_privilegedaccessmanager_v1::Result;
495 /// async fn sample(
496 /// client: &PrivilegedAccessManager
497 /// ) -> Result<()> {
498 /// let response = client.deny_grant()
499 /// /* set fields */
500 /// .send().await?;
501 /// println!("response {:?}", response);
502 /// Ok(())
503 /// }
504 /// ```
505 pub fn deny_grant(&self) -> super::builder::privileged_access_manager::DenyGrant {
506 super::builder::privileged_access_manager::DenyGrant::new(self.inner.clone())
507 }
508
509 /// `RevokeGrant` is used to immediately revoke access for a grant. This method
510 /// can be called when the grant is in a non-terminal state.
511 ///
512 /// # Long running operations
513 ///
514 /// This method is used to start, and/or poll a [long-running Operation].
515 /// The [Working with long-running operations] chapter in the [user guide]
516 /// covers these operations in detail.
517 ///
518 /// [long-running operation]: https://google.aip.dev/151
519 /// [user guide]: https://googleapis.github.io/google-cloud-rust/
520 /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
521 ///
522 /// # Example
523 /// ```
524 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
525 /// use google_cloud_lro::Poller;
526 /// use google_cloud_privilegedaccessmanager_v1::Result;
527 /// async fn sample(
528 /// client: &PrivilegedAccessManager
529 /// ) -> Result<()> {
530 /// let response = client.revoke_grant()
531 /// /* set fields */
532 /// .poller().until_done().await?;
533 /// println!("response {:?}", response);
534 /// Ok(())
535 /// }
536 /// ```
537 pub fn revoke_grant(&self) -> super::builder::privileged_access_manager::RevokeGrant {
538 super::builder::privileged_access_manager::RevokeGrant::new(self.inner.clone())
539 }
540
541 /// Lists information about the supported locations for this service.
542 ///
543 /// # Example
544 /// ```
545 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
546 /// use google_cloud_gax::paginator::ItemPaginator as _;
547 /// use google_cloud_privilegedaccessmanager_v1::Result;
548 /// async fn sample(
549 /// client: &PrivilegedAccessManager
550 /// ) -> Result<()> {
551 /// let mut list = client.list_locations()
552 /// /* set fields */
553 /// .by_item();
554 /// while let Some(item) = list.next().await.transpose()? {
555 /// println!("{:?}", item);
556 /// }
557 /// Ok(())
558 /// }
559 /// ```
560 pub fn list_locations(&self) -> super::builder::privileged_access_manager::ListLocations {
561 super::builder::privileged_access_manager::ListLocations::new(self.inner.clone())
562 }
563
564 /// Gets information about a location.
565 ///
566 /// # Example
567 /// ```
568 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
569 /// use google_cloud_privilegedaccessmanager_v1::Result;
570 /// async fn sample(
571 /// client: &PrivilegedAccessManager
572 /// ) -> Result<()> {
573 /// let response = client.get_location()
574 /// /* set fields */
575 /// .send().await?;
576 /// println!("response {:?}", response);
577 /// Ok(())
578 /// }
579 /// ```
580 pub fn get_location(&self) -> super::builder::privileged_access_manager::GetLocation {
581 super::builder::privileged_access_manager::GetLocation::new(self.inner.clone())
582 }
583
584 /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
585 ///
586 /// [google.longrunning.Operations]: google-cloud-longrunning::client::Operations
587 ///
588 /// # Example
589 /// ```
590 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
591 /// use google_cloud_gax::paginator::ItemPaginator as _;
592 /// use google_cloud_privilegedaccessmanager_v1::Result;
593 /// async fn sample(
594 /// client: &PrivilegedAccessManager
595 /// ) -> Result<()> {
596 /// let mut list = client.list_operations()
597 /// /* set fields */
598 /// .by_item();
599 /// while let Some(item) = list.next().await.transpose()? {
600 /// println!("{:?}", item);
601 /// }
602 /// Ok(())
603 /// }
604 /// ```
605 pub fn list_operations(&self) -> super::builder::privileged_access_manager::ListOperations {
606 super::builder::privileged_access_manager::ListOperations::new(self.inner.clone())
607 }
608
609 /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
610 ///
611 /// [google.longrunning.Operations]: google-cloud-longrunning::client::Operations
612 ///
613 /// # Example
614 /// ```
615 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
616 /// use google_cloud_privilegedaccessmanager_v1::Result;
617 /// async fn sample(
618 /// client: &PrivilegedAccessManager
619 /// ) -> Result<()> {
620 /// let response = client.get_operation()
621 /// /* set fields */
622 /// .send().await?;
623 /// println!("response {:?}", response);
624 /// Ok(())
625 /// }
626 /// ```
627 pub fn get_operation(&self) -> super::builder::privileged_access_manager::GetOperation {
628 super::builder::privileged_access_manager::GetOperation::new(self.inner.clone())
629 }
630
631 /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
632 ///
633 /// [google.longrunning.Operations]: google-cloud-longrunning::client::Operations
634 ///
635 /// # Example
636 /// ```
637 /// # use google_cloud_privilegedaccessmanager_v1::client::PrivilegedAccessManager;
638 /// use google_cloud_privilegedaccessmanager_v1::Result;
639 /// async fn sample(
640 /// client: &PrivilegedAccessManager
641 /// ) -> Result<()> {
642 /// client.delete_operation()
643 /// /* set fields */
644 /// .send().await?;
645 /// Ok(())
646 /// }
647 /// ```
648 pub fn delete_operation(&self) -> super::builder::privileged_access_manager::DeleteOperation {
649 super::builder::privileged_access_manager::DeleteOperation::new(self.inner.clone())
650 }
651}