google_cloud_dataform_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::bare_urls)]
17#![allow(rustdoc::broken_intra_doc_links)]
18#![allow(rustdoc::invalid_html_tags)]
19#![allow(rustdoc::redundant_explicit_links)]
20
21/// Implements a client for the Dataform API.
22///
23/// # Example
24/// ```
25/// # use google_cloud_dataform_v1::client::Dataform;
26/// use google_cloud_gax::paginator::ItemPaginator as _;
27/// async fn sample(
28/// parent: &str,
29/// ) -> anyhow::Result<()> {
30/// let client = Dataform::builder().build().await?;
31/// let mut list = client.list_repositories()
32/// .set_parent(parent)
33/// .by_item();
34/// while let Some(item) = list.next().await.transpose()? {
35/// println!("{:?}", item);
36/// }
37/// Ok(())
38/// }
39/// ```
40///
41/// # Service Description
42///
43/// Dataform is a service to develop, create, document, test, and update curated
44/// tables in BigQuery.
45///
46/// # Configuration
47///
48/// To configure `Dataform` use the `with_*` methods in the type returned
49/// by [builder()][Dataform::builder]. The default configuration should
50/// work for most applications. Common configuration changes include
51///
52/// * [with_endpoint()]: by default this client uses the global default endpoint
53/// (`https://dataform.googleapis.com`). Applications using regional
54/// endpoints or running in restricted networks (e.g. a network configured
55/// with [Private Google Access with VPC Service Controls]) may want to
56/// override this default.
57/// * [with_credentials()]: by default this client uses
58/// [Application Default Credentials]. Applications using custom
59/// authentication may need to override this default.
60///
61/// [with_endpoint()]: super::builder::dataform::ClientBuilder::with_endpoint
62/// [with_credentials()]: super::builder::dataform::ClientBuilder::with_credentials
63/// [Private Google Access with VPC Service Controls]: https://cloud.google.com/vpc-service-controls/docs/private-connectivity
64/// [Application Default Credentials]: https://cloud.google.com/docs/authentication#adc
65///
66/// # Pooling and Cloning
67///
68/// `Dataform` holds a connection pool internally, it is advised to
69/// create one and reuse it. You do not need to wrap `Dataform` in
70/// an [Rc](std::rc::Rc) or [Arc](std::sync::Arc) to reuse it, because it
71/// already uses an `Arc` internally.
72#[derive(Clone, Debug)]
73pub struct Dataform {
74 inner: std::sync::Arc<dyn super::stub::dynamic::Dataform>,
75}
76
77impl Dataform {
78 /// Returns a builder for [Dataform].
79 ///
80 /// ```
81 /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
82 /// # use google_cloud_dataform_v1::client::Dataform;
83 /// let client = Dataform::builder().build().await?;
84 /// # Ok(()) }
85 /// ```
86 pub fn builder() -> super::builder::dataform::ClientBuilder {
87 crate::new_client_builder(super::builder::dataform::client::Factory)
88 }
89
90 /// Creates a new client from the provided stub.
91 ///
92 /// The most common case for calling this function is in tests mocking the
93 /// client's behavior.
94 pub fn from_stub<T>(stub: impl Into<std::sync::Arc<T>>) -> Self
95 where
96 T: super::stub::Dataform + 'static,
97 {
98 Self { inner: stub.into() }
99 }
100
101 pub(crate) async fn new(
102 config: gaxi::options::ClientConfig,
103 ) -> crate::ClientBuilderResult<Self> {
104 let inner = Self::build_inner(config).await?;
105 Ok(Self { inner })
106 }
107
108 async fn build_inner(
109 conf: gaxi::options::ClientConfig,
110 ) -> crate::ClientBuilderResult<std::sync::Arc<dyn super::stub::dynamic::Dataform>> {
111 if gaxi::options::tracing_enabled(&conf) {
112 return Ok(std::sync::Arc::new(Self::build_with_tracing(conf).await?));
113 }
114 Ok(std::sync::Arc::new(Self::build_transport(conf).await?))
115 }
116
117 async fn build_transport(
118 conf: gaxi::options::ClientConfig,
119 ) -> crate::ClientBuilderResult<impl super::stub::Dataform> {
120 super::transport::Dataform::new(conf).await
121 }
122
123 async fn build_with_tracing(
124 conf: gaxi::options::ClientConfig,
125 ) -> crate::ClientBuilderResult<impl super::stub::Dataform> {
126 Self::build_transport(conf)
127 .await
128 .map(super::tracing::Dataform::new)
129 }
130
131 /// Fetches a single TeamFolder.
132 ///
133 /// # Example
134 /// ```
135 /// # use google_cloud_dataform_v1::client::Dataform;
136 /// use google_cloud_dataform_v1::Result;
137 /// async fn sample(
138 /// client: &Dataform, project_id: &str, location_id: &str, team_folder_id: &str
139 /// ) -> Result<()> {
140 /// let response = client.get_team_folder()
141 /// .set_name(format!("projects/{project_id}/locations/{location_id}/teamFolders/{team_folder_id}"))
142 /// .send().await?;
143 /// println!("response {:?}", response);
144 /// Ok(())
145 /// }
146 /// ```
147 pub fn get_team_folder(&self) -> super::builder::dataform::GetTeamFolder {
148 super::builder::dataform::GetTeamFolder::new(self.inner.clone())
149 }
150
151 /// Creates a new TeamFolder in a given project and location.
152 ///
153 /// # Example
154 /// ```
155 /// # use google_cloud_dataform_v1::client::Dataform;
156 /// use google_cloud_dataform_v1::model::TeamFolder;
157 /// use google_cloud_dataform_v1::Result;
158 /// async fn sample(
159 /// client: &Dataform, parent: &str
160 /// ) -> Result<()> {
161 /// let response = client.create_team_folder()
162 /// .set_parent(parent)
163 /// .set_team_folder(
164 /// TeamFolder::new()/* set fields */
165 /// )
166 /// .send().await?;
167 /// println!("response {:?}", response);
168 /// Ok(())
169 /// }
170 /// ```
171 pub fn create_team_folder(&self) -> super::builder::dataform::CreateTeamFolder {
172 super::builder::dataform::CreateTeamFolder::new(self.inner.clone())
173 }
174
175 /// Updates a single TeamFolder.
176 ///
177 /// # Example
178 /// ```
179 /// # use google_cloud_dataform_v1::client::Dataform;
180 /// # extern crate wkt as google_cloud_wkt;
181 /// use google_cloud_wkt::FieldMask;
182 /// use google_cloud_dataform_v1::model::TeamFolder;
183 /// use google_cloud_dataform_v1::Result;
184 /// async fn sample(
185 /// client: &Dataform, project_id: &str, location_id: &str, team_folder_id: &str
186 /// ) -> Result<()> {
187 /// let response = client.update_team_folder()
188 /// .set_team_folder(
189 /// TeamFolder::new().set_name(format!("projects/{project_id}/locations/{location_id}/teamFolders/{team_folder_id}"))/* set fields */
190 /// )
191 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
192 /// .send().await?;
193 /// println!("response {:?}", response);
194 /// Ok(())
195 /// }
196 /// ```
197 pub fn update_team_folder(&self) -> super::builder::dataform::UpdateTeamFolder {
198 super::builder::dataform::UpdateTeamFolder::new(self.inner.clone())
199 }
200
201 /// Deletes a single TeamFolder.
202 ///
203 /// # Example
204 /// ```
205 /// # use google_cloud_dataform_v1::client::Dataform;
206 /// use google_cloud_dataform_v1::Result;
207 /// async fn sample(
208 /// client: &Dataform, project_id: &str, location_id: &str, team_folder_id: &str
209 /// ) -> Result<()> {
210 /// client.delete_team_folder()
211 /// .set_name(format!("projects/{project_id}/locations/{location_id}/teamFolders/{team_folder_id}"))
212 /// .send().await?;
213 /// Ok(())
214 /// }
215 /// ```
216 pub fn delete_team_folder(&self) -> super::builder::dataform::DeleteTeamFolder {
217 super::builder::dataform::DeleteTeamFolder::new(self.inner.clone())
218 }
219
220 /// Deletes a TeamFolder with its contents (Folders, Repositories, Workspaces,
221 /// ReleaseConfigs, and WorkflowConfigs).
222 ///
223 /// # Long running operations
224 ///
225 /// This method is used to start, and/or poll a [long-running Operation].
226 /// The [Working with long-running operations] chapter in the [user guide]
227 /// covers these operations in detail.
228 ///
229 /// [long-running operation]: https://google.aip.dev/151
230 /// [user guide]: https://googleapis.github.io/google-cloud-rust/
231 /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
232 ///
233 /// # Example
234 /// ```
235 /// # use google_cloud_dataform_v1::client::Dataform;
236 /// use google_cloud_lro::Poller;
237 /// use google_cloud_dataform_v1::Result;
238 /// async fn sample(
239 /// client: &Dataform
240 /// ) -> Result<()> {
241 /// client.delete_team_folder_tree()
242 /// /* set fields */
243 /// .poller().until_done().await?;
244 /// Ok(())
245 /// }
246 /// ```
247 pub fn delete_team_folder_tree(&self) -> super::builder::dataform::DeleteTeamFolderTree {
248 super::builder::dataform::DeleteTeamFolderTree::new(self.inner.clone())
249 }
250
251 /// Returns the contents of a given TeamFolder.
252 ///
253 /// # Example
254 /// ```
255 /// # use google_cloud_dataform_v1::client::Dataform;
256 /// use google_cloud_gax::paginator::ItemPaginator as _;
257 /// use google_cloud_dataform_v1::Result;
258 /// async fn sample(
259 /// client: &Dataform
260 /// ) -> Result<()> {
261 /// let mut list = client.query_team_folder_contents()
262 /// /* set fields */
263 /// .by_item();
264 /// while let Some(item) = list.next().await.transpose()? {
265 /// println!("{:?}", item);
266 /// }
267 /// Ok(())
268 /// }
269 /// ```
270 pub fn query_team_folder_contents(&self) -> super::builder::dataform::QueryTeamFolderContents {
271 super::builder::dataform::QueryTeamFolderContents::new(self.inner.clone())
272 }
273
274 /// Returns all TeamFolders in a given location that the caller has access to
275 /// and match the provided filter.
276 ///
277 /// # Example
278 /// ```
279 /// # use google_cloud_dataform_v1::client::Dataform;
280 /// use google_cloud_gax::paginator::ItemPaginator as _;
281 /// use google_cloud_dataform_v1::Result;
282 /// async fn sample(
283 /// client: &Dataform
284 /// ) -> Result<()> {
285 /// let mut list = client.search_team_folders()
286 /// /* set fields */
287 /// .by_item();
288 /// while let Some(item) = list.next().await.transpose()? {
289 /// println!("{:?}", item);
290 /// }
291 /// Ok(())
292 /// }
293 /// ```
294 pub fn search_team_folders(&self) -> super::builder::dataform::SearchTeamFolders {
295 super::builder::dataform::SearchTeamFolders::new(self.inner.clone())
296 }
297
298 /// Fetches a single Folder.
299 ///
300 /// # Example
301 /// ```
302 /// # use google_cloud_dataform_v1::client::Dataform;
303 /// use google_cloud_dataform_v1::Result;
304 /// async fn sample(
305 /// client: &Dataform, project_id: &str, location_id: &str, folder_id: &str
306 /// ) -> Result<()> {
307 /// let response = client.get_folder()
308 /// .set_name(format!("projects/{project_id}/locations/{location_id}/folders/{folder_id}"))
309 /// .send().await?;
310 /// println!("response {:?}", response);
311 /// Ok(())
312 /// }
313 /// ```
314 pub fn get_folder(&self) -> super::builder::dataform::GetFolder {
315 super::builder::dataform::GetFolder::new(self.inner.clone())
316 }
317
318 /// Creates a new Folder in a given project and location.
319 ///
320 /// # Example
321 /// ```
322 /// # use google_cloud_dataform_v1::client::Dataform;
323 /// use google_cloud_dataform_v1::model::Folder;
324 /// use google_cloud_dataform_v1::Result;
325 /// async fn sample(
326 /// client: &Dataform, parent: &str
327 /// ) -> Result<()> {
328 /// let response = client.create_folder()
329 /// .set_parent(parent)
330 /// .set_folder(
331 /// Folder::new()/* set fields */
332 /// )
333 /// .send().await?;
334 /// println!("response {:?}", response);
335 /// Ok(())
336 /// }
337 /// ```
338 pub fn create_folder(&self) -> super::builder::dataform::CreateFolder {
339 super::builder::dataform::CreateFolder::new(self.inner.clone())
340 }
341
342 /// Updates a single Folder.
343 ///
344 /// # Example
345 /// ```
346 /// # use google_cloud_dataform_v1::client::Dataform;
347 /// # extern crate wkt as google_cloud_wkt;
348 /// use google_cloud_wkt::FieldMask;
349 /// use google_cloud_dataform_v1::model::Folder;
350 /// use google_cloud_dataform_v1::Result;
351 /// async fn sample(
352 /// client: &Dataform, project_id: &str, location_id: &str, folder_id: &str
353 /// ) -> Result<()> {
354 /// let response = client.update_folder()
355 /// .set_folder(
356 /// Folder::new().set_name(format!("projects/{project_id}/locations/{location_id}/folders/{folder_id}"))/* set fields */
357 /// )
358 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
359 /// .send().await?;
360 /// println!("response {:?}", response);
361 /// Ok(())
362 /// }
363 /// ```
364 pub fn update_folder(&self) -> super::builder::dataform::UpdateFolder {
365 super::builder::dataform::UpdateFolder::new(self.inner.clone())
366 }
367
368 /// Deletes a single Folder.
369 ///
370 /// # Example
371 /// ```
372 /// # use google_cloud_dataform_v1::client::Dataform;
373 /// use google_cloud_dataform_v1::Result;
374 /// async fn sample(
375 /// client: &Dataform, project_id: &str, location_id: &str, folder_id: &str
376 /// ) -> Result<()> {
377 /// client.delete_folder()
378 /// .set_name(format!("projects/{project_id}/locations/{location_id}/folders/{folder_id}"))
379 /// .send().await?;
380 /// Ok(())
381 /// }
382 /// ```
383 pub fn delete_folder(&self) -> super::builder::dataform::DeleteFolder {
384 super::builder::dataform::DeleteFolder::new(self.inner.clone())
385 }
386
387 /// Deletes a Folder with its contents (Folders, Repositories, Workspaces,
388 /// ReleaseConfigs, and WorkflowConfigs).
389 ///
390 /// # Long running operations
391 ///
392 /// This method is used to start, and/or poll a [long-running Operation].
393 /// The [Working with long-running operations] chapter in the [user guide]
394 /// covers these operations in detail.
395 ///
396 /// [long-running operation]: https://google.aip.dev/151
397 /// [user guide]: https://googleapis.github.io/google-cloud-rust/
398 /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
399 ///
400 /// # Example
401 /// ```
402 /// # use google_cloud_dataform_v1::client::Dataform;
403 /// use google_cloud_lro::Poller;
404 /// use google_cloud_dataform_v1::Result;
405 /// async fn sample(
406 /// client: &Dataform
407 /// ) -> Result<()> {
408 /// client.delete_folder_tree()
409 /// /* set fields */
410 /// .poller().until_done().await?;
411 /// Ok(())
412 /// }
413 /// ```
414 pub fn delete_folder_tree(&self) -> super::builder::dataform::DeleteFolderTree {
415 super::builder::dataform::DeleteFolderTree::new(self.inner.clone())
416 }
417
418 /// Returns the contents of a given Folder.
419 ///
420 /// # Example
421 /// ```
422 /// # use google_cloud_dataform_v1::client::Dataform;
423 /// use google_cloud_gax::paginator::ItemPaginator as _;
424 /// use google_cloud_dataform_v1::Result;
425 /// async fn sample(
426 /// client: &Dataform
427 /// ) -> Result<()> {
428 /// let mut list = client.query_folder_contents()
429 /// /* set fields */
430 /// .by_item();
431 /// while let Some(item) = list.next().await.transpose()? {
432 /// println!("{:?}", item);
433 /// }
434 /// Ok(())
435 /// }
436 /// ```
437 pub fn query_folder_contents(&self) -> super::builder::dataform::QueryFolderContents {
438 super::builder::dataform::QueryFolderContents::new(self.inner.clone())
439 }
440
441 /// Returns the contents of a caller's root folder in a given location.
442 /// The root folder contains all resources that are created by the user and not
443 /// contained in any other folder.
444 ///
445 /// # Example
446 /// ```
447 /// # use google_cloud_dataform_v1::client::Dataform;
448 /// use google_cloud_gax::paginator::ItemPaginator as _;
449 /// use google_cloud_dataform_v1::Result;
450 /// async fn sample(
451 /// client: &Dataform
452 /// ) -> Result<()> {
453 /// let mut list = client.query_user_root_contents()
454 /// /* set fields */
455 /// .by_item();
456 /// while let Some(item) = list.next().await.transpose()? {
457 /// println!("{:?}", item);
458 /// }
459 /// Ok(())
460 /// }
461 /// ```
462 pub fn query_user_root_contents(&self) -> super::builder::dataform::QueryUserRootContents {
463 super::builder::dataform::QueryUserRootContents::new(self.inner.clone())
464 }
465
466 /// Moves a Folder to a new Folder, TeamFolder, or the root location.
467 ///
468 /// # Long running operations
469 ///
470 /// This method is used to start, and/or poll a [long-running Operation].
471 /// The [Working with long-running operations] chapter in the [user guide]
472 /// covers these operations in detail.
473 ///
474 /// [long-running operation]: https://google.aip.dev/151
475 /// [user guide]: https://googleapis.github.io/google-cloud-rust/
476 /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
477 ///
478 /// # Example
479 /// ```
480 /// # use google_cloud_dataform_v1::client::Dataform;
481 /// use google_cloud_lro::Poller;
482 /// use google_cloud_dataform_v1::Result;
483 /// async fn sample(
484 /// client: &Dataform
485 /// ) -> Result<()> {
486 /// client.move_folder()
487 /// /* set fields */
488 /// .poller().until_done().await?;
489 /// Ok(())
490 /// }
491 /// ```
492 pub fn move_folder(&self) -> super::builder::dataform::MoveFolder {
493 super::builder::dataform::MoveFolder::new(self.inner.clone())
494 }
495
496 /// Lists Repositories in a given project and location.
497 ///
498 /// **Note:** *This method can return repositories not shown in the [Dataform
499 /// UI](https://console.cloud.google.com/bigquery/dataform)*.
500 ///
501 /// # Example
502 /// ```
503 /// # use google_cloud_dataform_v1::client::Dataform;
504 /// use google_cloud_gax::paginator::ItemPaginator as _;
505 /// use google_cloud_dataform_v1::Result;
506 /// async fn sample(
507 /// client: &Dataform, parent: &str
508 /// ) -> Result<()> {
509 /// let mut list = client.list_repositories()
510 /// .set_parent(parent)
511 /// .by_item();
512 /// while let Some(item) = list.next().await.transpose()? {
513 /// println!("{:?}", item);
514 /// }
515 /// Ok(())
516 /// }
517 /// ```
518 pub fn list_repositories(&self) -> super::builder::dataform::ListRepositories {
519 super::builder::dataform::ListRepositories::new(self.inner.clone())
520 }
521
522 /// Fetches a single Repository.
523 ///
524 /// # Example
525 /// ```
526 /// # use google_cloud_dataform_v1::client::Dataform;
527 /// use google_cloud_dataform_v1::Result;
528 /// async fn sample(
529 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
530 /// ) -> Result<()> {
531 /// let response = client.get_repository()
532 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
533 /// .send().await?;
534 /// println!("response {:?}", response);
535 /// Ok(())
536 /// }
537 /// ```
538 pub fn get_repository(&self) -> super::builder::dataform::GetRepository {
539 super::builder::dataform::GetRepository::new(self.inner.clone())
540 }
541
542 /// Creates a new Repository in a given project and location.
543 ///
544 /// # Example
545 /// ```
546 /// # use google_cloud_dataform_v1::client::Dataform;
547 /// use google_cloud_dataform_v1::model::Repository;
548 /// use google_cloud_dataform_v1::Result;
549 /// async fn sample(
550 /// client: &Dataform, parent: &str
551 /// ) -> Result<()> {
552 /// let response = client.create_repository()
553 /// .set_parent(parent)
554 /// .set_repository_id("repository_id_value")
555 /// .set_repository(
556 /// Repository::new()/* set fields */
557 /// )
558 /// .send().await?;
559 /// println!("response {:?}", response);
560 /// Ok(())
561 /// }
562 /// ```
563 pub fn create_repository(&self) -> super::builder::dataform::CreateRepository {
564 super::builder::dataform::CreateRepository::new(self.inner.clone())
565 }
566
567 /// Updates a single Repository.
568 ///
569 /// **Note:** *This method does not fully implement
570 /// [AIP/134](https://google.aip.dev/134). The wildcard entry (\*) is treated
571 /// as a bad request, and when the `field_mask` is omitted, the request is
572 /// treated as a full update on all modifiable fields.*
573 ///
574 /// # Example
575 /// ```
576 /// # use google_cloud_dataform_v1::client::Dataform;
577 /// # extern crate wkt as google_cloud_wkt;
578 /// use google_cloud_wkt::FieldMask;
579 /// use google_cloud_dataform_v1::model::Repository;
580 /// use google_cloud_dataform_v1::Result;
581 /// async fn sample(
582 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
583 /// ) -> Result<()> {
584 /// let response = client.update_repository()
585 /// .set_repository(
586 /// Repository::new().set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))/* set fields */
587 /// )
588 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
589 /// .send().await?;
590 /// println!("response {:?}", response);
591 /// Ok(())
592 /// }
593 /// ```
594 pub fn update_repository(&self) -> super::builder::dataform::UpdateRepository {
595 super::builder::dataform::UpdateRepository::new(self.inner.clone())
596 }
597
598 /// Deletes a single Repository.
599 ///
600 /// # Example
601 /// ```
602 /// # use google_cloud_dataform_v1::client::Dataform;
603 /// use google_cloud_dataform_v1::Result;
604 /// async fn sample(
605 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
606 /// ) -> Result<()> {
607 /// client.delete_repository()
608 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
609 /// .send().await?;
610 /// Ok(())
611 /// }
612 /// ```
613 pub fn delete_repository(&self) -> super::builder::dataform::DeleteRepository {
614 super::builder::dataform::DeleteRepository::new(self.inner.clone())
615 }
616
617 /// Moves a Repository to a new location.
618 ///
619 /// # Long running operations
620 ///
621 /// This method is used to start, and/or poll a [long-running Operation].
622 /// The [Working with long-running operations] chapter in the [user guide]
623 /// covers these operations in detail.
624 ///
625 /// [long-running operation]: https://google.aip.dev/151
626 /// [user guide]: https://googleapis.github.io/google-cloud-rust/
627 /// [working with long-running operations]: https://googleapis.github.io/google-cloud-rust/working_with_long_running_operations.html
628 ///
629 /// # Example
630 /// ```
631 /// # use google_cloud_dataform_v1::client::Dataform;
632 /// use google_cloud_lro::Poller;
633 /// use google_cloud_dataform_v1::Result;
634 /// async fn sample(
635 /// client: &Dataform
636 /// ) -> Result<()> {
637 /// client.move_repository()
638 /// /* set fields */
639 /// .poller().until_done().await?;
640 /// Ok(())
641 /// }
642 /// ```
643 pub fn move_repository(&self) -> super::builder::dataform::MoveRepository {
644 super::builder::dataform::MoveRepository::new(self.inner.clone())
645 }
646
647 /// Applies a Git commit to a Repository. The Repository must not have a value
648 /// for `git_remote_settings.url`.
649 ///
650 /// # Example
651 /// ```
652 /// # use google_cloud_dataform_v1::client::Dataform;
653 /// use google_cloud_dataform_v1::Result;
654 /// async fn sample(
655 /// client: &Dataform
656 /// ) -> Result<()> {
657 /// let response = client.commit_repository_changes()
658 /// /* set fields */
659 /// .send().await?;
660 /// println!("response {:?}", response);
661 /// Ok(())
662 /// }
663 /// ```
664 pub fn commit_repository_changes(&self) -> super::builder::dataform::CommitRepositoryChanges {
665 super::builder::dataform::CommitRepositoryChanges::new(self.inner.clone())
666 }
667
668 /// Returns the contents of a file (inside a Repository). The Repository
669 /// must not have a value for `git_remote_settings.url`.
670 ///
671 /// # Example
672 /// ```
673 /// # use google_cloud_dataform_v1::client::Dataform;
674 /// use google_cloud_dataform_v1::Result;
675 /// async fn sample(
676 /// client: &Dataform
677 /// ) -> Result<()> {
678 /// let response = client.read_repository_file()
679 /// /* set fields */
680 /// .send().await?;
681 /// println!("response {:?}", response);
682 /// Ok(())
683 /// }
684 /// ```
685 pub fn read_repository_file(&self) -> super::builder::dataform::ReadRepositoryFile {
686 super::builder::dataform::ReadRepositoryFile::new(self.inner.clone())
687 }
688
689 /// Returns the contents of a given Repository directory. The Repository must
690 /// not have a value for `git_remote_settings.url`.
691 ///
692 /// # Example
693 /// ```
694 /// # use google_cloud_dataform_v1::client::Dataform;
695 /// use google_cloud_gax::paginator::ItemPaginator as _;
696 /// use google_cloud_dataform_v1::Result;
697 /// async fn sample(
698 /// client: &Dataform
699 /// ) -> Result<()> {
700 /// let mut list = client.query_repository_directory_contents()
701 /// /* set fields */
702 /// .by_item();
703 /// while let Some(item) = list.next().await.transpose()? {
704 /// println!("{:?}", item);
705 /// }
706 /// Ok(())
707 /// }
708 /// ```
709 pub fn query_repository_directory_contents(
710 &self,
711 ) -> super::builder::dataform::QueryRepositoryDirectoryContents {
712 super::builder::dataform::QueryRepositoryDirectoryContents::new(self.inner.clone())
713 }
714
715 /// Fetches a Repository's history of commits. The Repository must not have a
716 /// value for `git_remote_settings.url`.
717 ///
718 /// # Example
719 /// ```
720 /// # use google_cloud_dataform_v1::client::Dataform;
721 /// use google_cloud_gax::paginator::ItemPaginator as _;
722 /// use google_cloud_dataform_v1::Result;
723 /// async fn sample(
724 /// client: &Dataform
725 /// ) -> Result<()> {
726 /// let mut list = client.fetch_repository_history()
727 /// /* set fields */
728 /// .by_item();
729 /// while let Some(item) = list.next().await.transpose()? {
730 /// println!("{:?}", item);
731 /// }
732 /// Ok(())
733 /// }
734 /// ```
735 pub fn fetch_repository_history(&self) -> super::builder::dataform::FetchRepositoryHistory {
736 super::builder::dataform::FetchRepositoryHistory::new(self.inner.clone())
737 }
738
739 /// Computes a Repository's Git access token status.
740 ///
741 /// # Example
742 /// ```
743 /// # use google_cloud_dataform_v1::client::Dataform;
744 /// use google_cloud_dataform_v1::Result;
745 /// async fn sample(
746 /// client: &Dataform
747 /// ) -> Result<()> {
748 /// let response = client.compute_repository_access_token_status()
749 /// /* set fields */
750 /// .send().await?;
751 /// println!("response {:?}", response);
752 /// Ok(())
753 /// }
754 /// ```
755 pub fn compute_repository_access_token_status(
756 &self,
757 ) -> super::builder::dataform::ComputeRepositoryAccessTokenStatus {
758 super::builder::dataform::ComputeRepositoryAccessTokenStatus::new(self.inner.clone())
759 }
760
761 /// Fetches a Repository's remote branches.
762 ///
763 /// # Example
764 /// ```
765 /// # use google_cloud_dataform_v1::client::Dataform;
766 /// use google_cloud_dataform_v1::Result;
767 /// async fn sample(
768 /// client: &Dataform
769 /// ) -> Result<()> {
770 /// let response = client.fetch_remote_branches()
771 /// /* set fields */
772 /// .send().await?;
773 /// println!("response {:?}", response);
774 /// Ok(())
775 /// }
776 /// ```
777 pub fn fetch_remote_branches(&self) -> super::builder::dataform::FetchRemoteBranches {
778 super::builder::dataform::FetchRemoteBranches::new(self.inner.clone())
779 }
780
781 /// Lists Workspaces in a given Repository.
782 ///
783 /// # Example
784 /// ```
785 /// # use google_cloud_dataform_v1::client::Dataform;
786 /// use google_cloud_gax::paginator::ItemPaginator as _;
787 /// use google_cloud_dataform_v1::Result;
788 /// async fn sample(
789 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
790 /// ) -> Result<()> {
791 /// let mut list = client.list_workspaces()
792 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
793 /// .by_item();
794 /// while let Some(item) = list.next().await.transpose()? {
795 /// println!("{:?}", item);
796 /// }
797 /// Ok(())
798 /// }
799 /// ```
800 pub fn list_workspaces(&self) -> super::builder::dataform::ListWorkspaces {
801 super::builder::dataform::ListWorkspaces::new(self.inner.clone())
802 }
803
804 /// Fetches a single Workspace.
805 ///
806 /// # Example
807 /// ```
808 /// # use google_cloud_dataform_v1::client::Dataform;
809 /// use google_cloud_dataform_v1::Result;
810 /// async fn sample(
811 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, workspace_id: &str
812 /// ) -> Result<()> {
813 /// let response = client.get_workspace()
814 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/workspaces/{workspace_id}"))
815 /// .send().await?;
816 /// println!("response {:?}", response);
817 /// Ok(())
818 /// }
819 /// ```
820 pub fn get_workspace(&self) -> super::builder::dataform::GetWorkspace {
821 super::builder::dataform::GetWorkspace::new(self.inner.clone())
822 }
823
824 /// Creates a new Workspace in a given Repository.
825 ///
826 /// # Example
827 /// ```
828 /// # use google_cloud_dataform_v1::client::Dataform;
829 /// use google_cloud_dataform_v1::model::Workspace;
830 /// use google_cloud_dataform_v1::Result;
831 /// async fn sample(
832 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
833 /// ) -> Result<()> {
834 /// let response = client.create_workspace()
835 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
836 /// .set_workspace_id("workspace_id_value")
837 /// .set_workspace(
838 /// Workspace::new()/* set fields */
839 /// )
840 /// .send().await?;
841 /// println!("response {:?}", response);
842 /// Ok(())
843 /// }
844 /// ```
845 pub fn create_workspace(&self) -> super::builder::dataform::CreateWorkspace {
846 super::builder::dataform::CreateWorkspace::new(self.inner.clone())
847 }
848
849 /// Deletes a single Workspace.
850 ///
851 /// # Example
852 /// ```
853 /// # use google_cloud_dataform_v1::client::Dataform;
854 /// use google_cloud_dataform_v1::Result;
855 /// async fn sample(
856 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, workspace_id: &str
857 /// ) -> Result<()> {
858 /// client.delete_workspace()
859 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/workspaces/{workspace_id}"))
860 /// .send().await?;
861 /// Ok(())
862 /// }
863 /// ```
864 pub fn delete_workspace(&self) -> super::builder::dataform::DeleteWorkspace {
865 super::builder::dataform::DeleteWorkspace::new(self.inner.clone())
866 }
867
868 /// Installs dependency NPM packages (inside a Workspace).
869 ///
870 /// # Example
871 /// ```
872 /// # use google_cloud_dataform_v1::client::Dataform;
873 /// use google_cloud_dataform_v1::Result;
874 /// async fn sample(
875 /// client: &Dataform
876 /// ) -> Result<()> {
877 /// let response = client.install_npm_packages()
878 /// /* set fields */
879 /// .send().await?;
880 /// println!("response {:?}", response);
881 /// Ok(())
882 /// }
883 /// ```
884 pub fn install_npm_packages(&self) -> super::builder::dataform::InstallNpmPackages {
885 super::builder::dataform::InstallNpmPackages::new(self.inner.clone())
886 }
887
888 /// Pulls Git commits from the Repository's remote into a Workspace.
889 ///
890 /// # Example
891 /// ```
892 /// # use google_cloud_dataform_v1::client::Dataform;
893 /// use google_cloud_dataform_v1::Result;
894 /// async fn sample(
895 /// client: &Dataform
896 /// ) -> Result<()> {
897 /// let response = client.pull_git_commits()
898 /// /* set fields */
899 /// .send().await?;
900 /// println!("response {:?}", response);
901 /// Ok(())
902 /// }
903 /// ```
904 pub fn pull_git_commits(&self) -> super::builder::dataform::PullGitCommits {
905 super::builder::dataform::PullGitCommits::new(self.inner.clone())
906 }
907
908 /// Pushes Git commits from a Workspace to the Repository's remote.
909 ///
910 /// # Example
911 /// ```
912 /// # use google_cloud_dataform_v1::client::Dataform;
913 /// use google_cloud_dataform_v1::Result;
914 /// async fn sample(
915 /// client: &Dataform
916 /// ) -> Result<()> {
917 /// let response = client.push_git_commits()
918 /// /* set fields */
919 /// .send().await?;
920 /// println!("response {:?}", response);
921 /// Ok(())
922 /// }
923 /// ```
924 pub fn push_git_commits(&self) -> super::builder::dataform::PushGitCommits {
925 super::builder::dataform::PushGitCommits::new(self.inner.clone())
926 }
927
928 /// Fetches Git statuses for the files in a Workspace.
929 ///
930 /// # Example
931 /// ```
932 /// # use google_cloud_dataform_v1::client::Dataform;
933 /// use google_cloud_dataform_v1::Result;
934 /// async fn sample(
935 /// client: &Dataform
936 /// ) -> Result<()> {
937 /// let response = client.fetch_file_git_statuses()
938 /// /* set fields */
939 /// .send().await?;
940 /// println!("response {:?}", response);
941 /// Ok(())
942 /// }
943 /// ```
944 pub fn fetch_file_git_statuses(&self) -> super::builder::dataform::FetchFileGitStatuses {
945 super::builder::dataform::FetchFileGitStatuses::new(self.inner.clone())
946 }
947
948 /// Fetches Git ahead/behind against a remote branch.
949 ///
950 /// # Example
951 /// ```
952 /// # use google_cloud_dataform_v1::client::Dataform;
953 /// use google_cloud_dataform_v1::Result;
954 /// async fn sample(
955 /// client: &Dataform
956 /// ) -> Result<()> {
957 /// let response = client.fetch_git_ahead_behind()
958 /// /* set fields */
959 /// .send().await?;
960 /// println!("response {:?}", response);
961 /// Ok(())
962 /// }
963 /// ```
964 pub fn fetch_git_ahead_behind(&self) -> super::builder::dataform::FetchGitAheadBehind {
965 super::builder::dataform::FetchGitAheadBehind::new(self.inner.clone())
966 }
967
968 /// Applies a Git commit for uncommitted files in a Workspace.
969 ///
970 /// # Example
971 /// ```
972 /// # use google_cloud_dataform_v1::client::Dataform;
973 /// use google_cloud_dataform_v1::Result;
974 /// async fn sample(
975 /// client: &Dataform
976 /// ) -> Result<()> {
977 /// let response = client.commit_workspace_changes()
978 /// /* set fields */
979 /// .send().await?;
980 /// println!("response {:?}", response);
981 /// Ok(())
982 /// }
983 /// ```
984 pub fn commit_workspace_changes(&self) -> super::builder::dataform::CommitWorkspaceChanges {
985 super::builder::dataform::CommitWorkspaceChanges::new(self.inner.clone())
986 }
987
988 /// Performs a Git reset for uncommitted files in a Workspace.
989 ///
990 /// # Example
991 /// ```
992 /// # use google_cloud_dataform_v1::client::Dataform;
993 /// use google_cloud_dataform_v1::Result;
994 /// async fn sample(
995 /// client: &Dataform
996 /// ) -> Result<()> {
997 /// let response = client.reset_workspace_changes()
998 /// /* set fields */
999 /// .send().await?;
1000 /// println!("response {:?}", response);
1001 /// Ok(())
1002 /// }
1003 /// ```
1004 pub fn reset_workspace_changes(&self) -> super::builder::dataform::ResetWorkspaceChanges {
1005 super::builder::dataform::ResetWorkspaceChanges::new(self.inner.clone())
1006 }
1007
1008 /// Fetches Git diff for an uncommitted file in a Workspace.
1009 ///
1010 /// # Example
1011 /// ```
1012 /// # use google_cloud_dataform_v1::client::Dataform;
1013 /// use google_cloud_dataform_v1::Result;
1014 /// async fn sample(
1015 /// client: &Dataform
1016 /// ) -> Result<()> {
1017 /// let response = client.fetch_file_diff()
1018 /// /* set fields */
1019 /// .send().await?;
1020 /// println!("response {:?}", response);
1021 /// Ok(())
1022 /// }
1023 /// ```
1024 pub fn fetch_file_diff(&self) -> super::builder::dataform::FetchFileDiff {
1025 super::builder::dataform::FetchFileDiff::new(self.inner.clone())
1026 }
1027
1028 /// Returns the contents of a given Workspace directory.
1029 ///
1030 /// # Example
1031 /// ```
1032 /// # use google_cloud_dataform_v1::client::Dataform;
1033 /// use google_cloud_gax::paginator::ItemPaginator as _;
1034 /// use google_cloud_dataform_v1::Result;
1035 /// async fn sample(
1036 /// client: &Dataform
1037 /// ) -> Result<()> {
1038 /// let mut list = client.query_directory_contents()
1039 /// /* set fields */
1040 /// .by_item();
1041 /// while let Some(item) = list.next().await.transpose()? {
1042 /// println!("{:?}", item);
1043 /// }
1044 /// Ok(())
1045 /// }
1046 /// ```
1047 pub fn query_directory_contents(&self) -> super::builder::dataform::QueryDirectoryContents {
1048 super::builder::dataform::QueryDirectoryContents::new(self.inner.clone())
1049 }
1050
1051 /// Finds the contents of a given Workspace directory by filter.
1052 ///
1053 /// # Example
1054 /// ```
1055 /// # use google_cloud_dataform_v1::client::Dataform;
1056 /// use google_cloud_gax::paginator::ItemPaginator as _;
1057 /// use google_cloud_dataform_v1::Result;
1058 /// async fn sample(
1059 /// client: &Dataform
1060 /// ) -> Result<()> {
1061 /// let mut list = client.search_files()
1062 /// /* set fields */
1063 /// .by_item();
1064 /// while let Some(item) = list.next().await.transpose()? {
1065 /// println!("{:?}", item);
1066 /// }
1067 /// Ok(())
1068 /// }
1069 /// ```
1070 pub fn search_files(&self) -> super::builder::dataform::SearchFiles {
1071 super::builder::dataform::SearchFiles::new(self.inner.clone())
1072 }
1073
1074 /// Creates a directory inside a Workspace.
1075 ///
1076 /// # Example
1077 /// ```
1078 /// # use google_cloud_dataform_v1::client::Dataform;
1079 /// use google_cloud_dataform_v1::Result;
1080 /// async fn sample(
1081 /// client: &Dataform
1082 /// ) -> Result<()> {
1083 /// let response = client.make_directory()
1084 /// /* set fields */
1085 /// .send().await?;
1086 /// println!("response {:?}", response);
1087 /// Ok(())
1088 /// }
1089 /// ```
1090 pub fn make_directory(&self) -> super::builder::dataform::MakeDirectory {
1091 super::builder::dataform::MakeDirectory::new(self.inner.clone())
1092 }
1093
1094 /// Deletes a directory (inside a Workspace) and all of its contents.
1095 ///
1096 /// # Example
1097 /// ```
1098 /// # use google_cloud_dataform_v1::client::Dataform;
1099 /// use google_cloud_dataform_v1::Result;
1100 /// async fn sample(
1101 /// client: &Dataform
1102 /// ) -> Result<()> {
1103 /// let response = client.remove_directory()
1104 /// /* set fields */
1105 /// .send().await?;
1106 /// println!("response {:?}", response);
1107 /// Ok(())
1108 /// }
1109 /// ```
1110 pub fn remove_directory(&self) -> super::builder::dataform::RemoveDirectory {
1111 super::builder::dataform::RemoveDirectory::new(self.inner.clone())
1112 }
1113
1114 /// Moves a directory (inside a Workspace), and all of its contents, to a new
1115 /// location.
1116 ///
1117 /// # Example
1118 /// ```
1119 /// # use google_cloud_dataform_v1::client::Dataform;
1120 /// use google_cloud_dataform_v1::Result;
1121 /// async fn sample(
1122 /// client: &Dataform
1123 /// ) -> Result<()> {
1124 /// let response = client.move_directory()
1125 /// /* set fields */
1126 /// .send().await?;
1127 /// println!("response {:?}", response);
1128 /// Ok(())
1129 /// }
1130 /// ```
1131 pub fn move_directory(&self) -> super::builder::dataform::MoveDirectory {
1132 super::builder::dataform::MoveDirectory::new(self.inner.clone())
1133 }
1134
1135 /// Returns the contents of a file (inside a Workspace).
1136 ///
1137 /// # Example
1138 /// ```
1139 /// # use google_cloud_dataform_v1::client::Dataform;
1140 /// use google_cloud_dataform_v1::Result;
1141 /// async fn sample(
1142 /// client: &Dataform
1143 /// ) -> Result<()> {
1144 /// let response = client.read_file()
1145 /// /* set fields */
1146 /// .send().await?;
1147 /// println!("response {:?}", response);
1148 /// Ok(())
1149 /// }
1150 /// ```
1151 pub fn read_file(&self) -> super::builder::dataform::ReadFile {
1152 super::builder::dataform::ReadFile::new(self.inner.clone())
1153 }
1154
1155 /// Deletes a file (inside a Workspace).
1156 ///
1157 /// # Example
1158 /// ```
1159 /// # use google_cloud_dataform_v1::client::Dataform;
1160 /// use google_cloud_dataform_v1::Result;
1161 /// async fn sample(
1162 /// client: &Dataform
1163 /// ) -> Result<()> {
1164 /// let response = client.remove_file()
1165 /// /* set fields */
1166 /// .send().await?;
1167 /// println!("response {:?}", response);
1168 /// Ok(())
1169 /// }
1170 /// ```
1171 pub fn remove_file(&self) -> super::builder::dataform::RemoveFile {
1172 super::builder::dataform::RemoveFile::new(self.inner.clone())
1173 }
1174
1175 /// Moves a file (inside a Workspace) to a new location.
1176 ///
1177 /// # Example
1178 /// ```
1179 /// # use google_cloud_dataform_v1::client::Dataform;
1180 /// use google_cloud_dataform_v1::Result;
1181 /// async fn sample(
1182 /// client: &Dataform
1183 /// ) -> Result<()> {
1184 /// let response = client.move_file()
1185 /// /* set fields */
1186 /// .send().await?;
1187 /// println!("response {:?}", response);
1188 /// Ok(())
1189 /// }
1190 /// ```
1191 pub fn move_file(&self) -> super::builder::dataform::MoveFile {
1192 super::builder::dataform::MoveFile::new(self.inner.clone())
1193 }
1194
1195 /// Writes to a file (inside a Workspace).
1196 ///
1197 /// # Example
1198 /// ```
1199 /// # use google_cloud_dataform_v1::client::Dataform;
1200 /// use google_cloud_dataform_v1::Result;
1201 /// async fn sample(
1202 /// client: &Dataform
1203 /// ) -> Result<()> {
1204 /// let response = client.write_file()
1205 /// /* set fields */
1206 /// .send().await?;
1207 /// println!("response {:?}", response);
1208 /// Ok(())
1209 /// }
1210 /// ```
1211 pub fn write_file(&self) -> super::builder::dataform::WriteFile {
1212 super::builder::dataform::WriteFile::new(self.inner.clone())
1213 }
1214
1215 /// Lists ReleaseConfigs in a given Repository.
1216 ///
1217 /// # Example
1218 /// ```
1219 /// # use google_cloud_dataform_v1::client::Dataform;
1220 /// use google_cloud_gax::paginator::ItemPaginator as _;
1221 /// use google_cloud_dataform_v1::Result;
1222 /// async fn sample(
1223 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
1224 /// ) -> Result<()> {
1225 /// let mut list = client.list_release_configs()
1226 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
1227 /// .by_item();
1228 /// while let Some(item) = list.next().await.transpose()? {
1229 /// println!("{:?}", item);
1230 /// }
1231 /// Ok(())
1232 /// }
1233 /// ```
1234 pub fn list_release_configs(&self) -> super::builder::dataform::ListReleaseConfigs {
1235 super::builder::dataform::ListReleaseConfigs::new(self.inner.clone())
1236 }
1237
1238 /// Fetches a single ReleaseConfig.
1239 ///
1240 /// # Example
1241 /// ```
1242 /// # use google_cloud_dataform_v1::client::Dataform;
1243 /// use google_cloud_dataform_v1::Result;
1244 /// async fn sample(
1245 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, release_config_id: &str
1246 /// ) -> Result<()> {
1247 /// let response = client.get_release_config()
1248 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/releaseConfigs/{release_config_id}"))
1249 /// .send().await?;
1250 /// println!("response {:?}", response);
1251 /// Ok(())
1252 /// }
1253 /// ```
1254 pub fn get_release_config(&self) -> super::builder::dataform::GetReleaseConfig {
1255 super::builder::dataform::GetReleaseConfig::new(self.inner.clone())
1256 }
1257
1258 /// Creates a new ReleaseConfig in a given Repository.
1259 ///
1260 /// # Example
1261 /// ```
1262 /// # use google_cloud_dataform_v1::client::Dataform;
1263 /// use google_cloud_dataform_v1::model::ReleaseConfig;
1264 /// use google_cloud_dataform_v1::Result;
1265 /// async fn sample(
1266 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
1267 /// ) -> Result<()> {
1268 /// let response = client.create_release_config()
1269 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
1270 /// .set_release_config(
1271 /// ReleaseConfig::new()/* set fields */
1272 /// )
1273 /// .send().await?;
1274 /// println!("response {:?}", response);
1275 /// Ok(())
1276 /// }
1277 /// ```
1278 pub fn create_release_config(&self) -> super::builder::dataform::CreateReleaseConfig {
1279 super::builder::dataform::CreateReleaseConfig::new(self.inner.clone())
1280 }
1281
1282 /// Updates a single ReleaseConfig.
1283 ///
1284 /// **Note:** *This method does not fully implement
1285 /// [AIP/134](https://google.aip.dev/134). The wildcard entry (\*) is treated
1286 /// as a bad request, and when the `field_mask` is omitted, the request is
1287 /// treated as a full update on all modifiable fields.*
1288 ///
1289 /// # Example
1290 /// ```
1291 /// # use google_cloud_dataform_v1::client::Dataform;
1292 /// # extern crate wkt as google_cloud_wkt;
1293 /// use google_cloud_wkt::FieldMask;
1294 /// use google_cloud_dataform_v1::model::ReleaseConfig;
1295 /// use google_cloud_dataform_v1::Result;
1296 /// async fn sample(
1297 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, release_config_id: &str
1298 /// ) -> Result<()> {
1299 /// let response = client.update_release_config()
1300 /// .set_release_config(
1301 /// ReleaseConfig::new().set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/releaseConfigs/{release_config_id}"))/* set fields */
1302 /// )
1303 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
1304 /// .send().await?;
1305 /// println!("response {:?}", response);
1306 /// Ok(())
1307 /// }
1308 /// ```
1309 pub fn update_release_config(&self) -> super::builder::dataform::UpdateReleaseConfig {
1310 super::builder::dataform::UpdateReleaseConfig::new(self.inner.clone())
1311 }
1312
1313 /// Deletes a single ReleaseConfig.
1314 ///
1315 /// # Example
1316 /// ```
1317 /// # use google_cloud_dataform_v1::client::Dataform;
1318 /// use google_cloud_dataform_v1::Result;
1319 /// async fn sample(
1320 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, release_config_id: &str
1321 /// ) -> Result<()> {
1322 /// client.delete_release_config()
1323 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/releaseConfigs/{release_config_id}"))
1324 /// .send().await?;
1325 /// Ok(())
1326 /// }
1327 /// ```
1328 pub fn delete_release_config(&self) -> super::builder::dataform::DeleteReleaseConfig {
1329 super::builder::dataform::DeleteReleaseConfig::new(self.inner.clone())
1330 }
1331
1332 /// Lists CompilationResults in a given Repository.
1333 ///
1334 /// # Example
1335 /// ```
1336 /// # use google_cloud_dataform_v1::client::Dataform;
1337 /// use google_cloud_gax::paginator::ItemPaginator as _;
1338 /// use google_cloud_dataform_v1::Result;
1339 /// async fn sample(
1340 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
1341 /// ) -> Result<()> {
1342 /// let mut list = client.list_compilation_results()
1343 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
1344 /// .by_item();
1345 /// while let Some(item) = list.next().await.transpose()? {
1346 /// println!("{:?}", item);
1347 /// }
1348 /// Ok(())
1349 /// }
1350 /// ```
1351 pub fn list_compilation_results(&self) -> super::builder::dataform::ListCompilationResults {
1352 super::builder::dataform::ListCompilationResults::new(self.inner.clone())
1353 }
1354
1355 /// Fetches a single CompilationResult.
1356 ///
1357 /// # Example
1358 /// ```
1359 /// # use google_cloud_dataform_v1::client::Dataform;
1360 /// use google_cloud_dataform_v1::Result;
1361 /// async fn sample(
1362 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, compilation_result_id: &str
1363 /// ) -> Result<()> {
1364 /// let response = client.get_compilation_result()
1365 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/compilationResults/{compilation_result_id}"))
1366 /// .send().await?;
1367 /// println!("response {:?}", response);
1368 /// Ok(())
1369 /// }
1370 /// ```
1371 pub fn get_compilation_result(&self) -> super::builder::dataform::GetCompilationResult {
1372 super::builder::dataform::GetCompilationResult::new(self.inner.clone())
1373 }
1374
1375 /// Creates a new CompilationResult in a given project and location.
1376 ///
1377 /// # Example
1378 /// ```
1379 /// # use google_cloud_dataform_v1::client::Dataform;
1380 /// use google_cloud_dataform_v1::model::CompilationResult;
1381 /// use google_cloud_dataform_v1::Result;
1382 /// async fn sample(
1383 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
1384 /// ) -> Result<()> {
1385 /// let response = client.create_compilation_result()
1386 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
1387 /// .set_compilation_result(
1388 /// CompilationResult::new()/* set fields */
1389 /// )
1390 /// .send().await?;
1391 /// println!("response {:?}", response);
1392 /// Ok(())
1393 /// }
1394 /// ```
1395 pub fn create_compilation_result(&self) -> super::builder::dataform::CreateCompilationResult {
1396 super::builder::dataform::CreateCompilationResult::new(self.inner.clone())
1397 }
1398
1399 /// Returns CompilationResultActions in a given CompilationResult.
1400 ///
1401 /// # Example
1402 /// ```
1403 /// # use google_cloud_dataform_v1::client::Dataform;
1404 /// use google_cloud_gax::paginator::ItemPaginator as _;
1405 /// use google_cloud_dataform_v1::Result;
1406 /// async fn sample(
1407 /// client: &Dataform
1408 /// ) -> Result<()> {
1409 /// let mut list = client.query_compilation_result_actions()
1410 /// /* set fields */
1411 /// .by_item();
1412 /// while let Some(item) = list.next().await.transpose()? {
1413 /// println!("{:?}", item);
1414 /// }
1415 /// Ok(())
1416 /// }
1417 /// ```
1418 pub fn query_compilation_result_actions(
1419 &self,
1420 ) -> super::builder::dataform::QueryCompilationResultActions {
1421 super::builder::dataform::QueryCompilationResultActions::new(self.inner.clone())
1422 }
1423
1424 /// Lists WorkflowConfigs in a given Repository.
1425 ///
1426 /// # Example
1427 /// ```
1428 /// # use google_cloud_dataform_v1::client::Dataform;
1429 /// use google_cloud_gax::paginator::ItemPaginator as _;
1430 /// use google_cloud_dataform_v1::Result;
1431 /// async fn sample(
1432 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
1433 /// ) -> Result<()> {
1434 /// let mut list = client.list_workflow_configs()
1435 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
1436 /// .by_item();
1437 /// while let Some(item) = list.next().await.transpose()? {
1438 /// println!("{:?}", item);
1439 /// }
1440 /// Ok(())
1441 /// }
1442 /// ```
1443 pub fn list_workflow_configs(&self) -> super::builder::dataform::ListWorkflowConfigs {
1444 super::builder::dataform::ListWorkflowConfigs::new(self.inner.clone())
1445 }
1446
1447 /// Fetches a single WorkflowConfig.
1448 ///
1449 /// # Example
1450 /// ```
1451 /// # use google_cloud_dataform_v1::client::Dataform;
1452 /// use google_cloud_dataform_v1::Result;
1453 /// async fn sample(
1454 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, workflow_config_id: &str
1455 /// ) -> Result<()> {
1456 /// let response = client.get_workflow_config()
1457 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/workflowConfigs/{workflow_config_id}"))
1458 /// .send().await?;
1459 /// println!("response {:?}", response);
1460 /// Ok(())
1461 /// }
1462 /// ```
1463 pub fn get_workflow_config(&self) -> super::builder::dataform::GetWorkflowConfig {
1464 super::builder::dataform::GetWorkflowConfig::new(self.inner.clone())
1465 }
1466
1467 /// Creates a new WorkflowConfig in a given Repository.
1468 ///
1469 /// # Example
1470 /// ```
1471 /// # use google_cloud_dataform_v1::client::Dataform;
1472 /// use google_cloud_dataform_v1::model::WorkflowConfig;
1473 /// use google_cloud_dataform_v1::Result;
1474 /// async fn sample(
1475 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
1476 /// ) -> Result<()> {
1477 /// let response = client.create_workflow_config()
1478 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
1479 /// .set_workflow_config(
1480 /// WorkflowConfig::new()/* set fields */
1481 /// )
1482 /// .send().await?;
1483 /// println!("response {:?}", response);
1484 /// Ok(())
1485 /// }
1486 /// ```
1487 pub fn create_workflow_config(&self) -> super::builder::dataform::CreateWorkflowConfig {
1488 super::builder::dataform::CreateWorkflowConfig::new(self.inner.clone())
1489 }
1490
1491 /// Updates a single WorkflowConfig.
1492 ///
1493 /// **Note:** *This method does not fully implement
1494 /// [AIP/134](https://google.aip.dev/134). The wildcard entry (\*) is treated
1495 /// as a bad request, and when the `field_mask` is omitted, the request is
1496 /// treated as a full update on all modifiable fields.*
1497 ///
1498 /// # Example
1499 /// ```
1500 /// # use google_cloud_dataform_v1::client::Dataform;
1501 /// # extern crate wkt as google_cloud_wkt;
1502 /// use google_cloud_wkt::FieldMask;
1503 /// use google_cloud_dataform_v1::model::WorkflowConfig;
1504 /// use google_cloud_dataform_v1::Result;
1505 /// async fn sample(
1506 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, workflow_config_id: &str
1507 /// ) -> Result<()> {
1508 /// let response = client.update_workflow_config()
1509 /// .set_workflow_config(
1510 /// WorkflowConfig::new().set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/workflowConfigs/{workflow_config_id}"))/* set fields */
1511 /// )
1512 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
1513 /// .send().await?;
1514 /// println!("response {:?}", response);
1515 /// Ok(())
1516 /// }
1517 /// ```
1518 pub fn update_workflow_config(&self) -> super::builder::dataform::UpdateWorkflowConfig {
1519 super::builder::dataform::UpdateWorkflowConfig::new(self.inner.clone())
1520 }
1521
1522 /// Deletes a single WorkflowConfig.
1523 ///
1524 /// # Example
1525 /// ```
1526 /// # use google_cloud_dataform_v1::client::Dataform;
1527 /// use google_cloud_dataform_v1::Result;
1528 /// async fn sample(
1529 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, workflow_config_id: &str
1530 /// ) -> Result<()> {
1531 /// client.delete_workflow_config()
1532 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/workflowConfigs/{workflow_config_id}"))
1533 /// .send().await?;
1534 /// Ok(())
1535 /// }
1536 /// ```
1537 pub fn delete_workflow_config(&self) -> super::builder::dataform::DeleteWorkflowConfig {
1538 super::builder::dataform::DeleteWorkflowConfig::new(self.inner.clone())
1539 }
1540
1541 /// Lists WorkflowInvocations in a given Repository.
1542 ///
1543 /// # Example
1544 /// ```
1545 /// # use google_cloud_dataform_v1::client::Dataform;
1546 /// use google_cloud_gax::paginator::ItemPaginator as _;
1547 /// use google_cloud_dataform_v1::Result;
1548 /// async fn sample(
1549 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
1550 /// ) -> Result<()> {
1551 /// let mut list = client.list_workflow_invocations()
1552 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
1553 /// .by_item();
1554 /// while let Some(item) = list.next().await.transpose()? {
1555 /// println!("{:?}", item);
1556 /// }
1557 /// Ok(())
1558 /// }
1559 /// ```
1560 pub fn list_workflow_invocations(&self) -> super::builder::dataform::ListWorkflowInvocations {
1561 super::builder::dataform::ListWorkflowInvocations::new(self.inner.clone())
1562 }
1563
1564 /// Fetches a single WorkflowInvocation.
1565 ///
1566 /// # Example
1567 /// ```
1568 /// # use google_cloud_dataform_v1::client::Dataform;
1569 /// use google_cloud_dataform_v1::Result;
1570 /// async fn sample(
1571 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, workflow_invocation_id: &str
1572 /// ) -> Result<()> {
1573 /// let response = client.get_workflow_invocation()
1574 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/workflowInvocations/{workflow_invocation_id}"))
1575 /// .send().await?;
1576 /// println!("response {:?}", response);
1577 /// Ok(())
1578 /// }
1579 /// ```
1580 pub fn get_workflow_invocation(&self) -> super::builder::dataform::GetWorkflowInvocation {
1581 super::builder::dataform::GetWorkflowInvocation::new(self.inner.clone())
1582 }
1583
1584 /// Creates a new WorkflowInvocation in a given Repository.
1585 ///
1586 /// # Example
1587 /// ```
1588 /// # use google_cloud_dataform_v1::client::Dataform;
1589 /// use google_cloud_dataform_v1::model::WorkflowInvocation;
1590 /// use google_cloud_dataform_v1::Result;
1591 /// async fn sample(
1592 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str
1593 /// ) -> Result<()> {
1594 /// let response = client.create_workflow_invocation()
1595 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}"))
1596 /// .set_workflow_invocation(
1597 /// WorkflowInvocation::new()/* set fields */
1598 /// )
1599 /// .send().await?;
1600 /// println!("response {:?}", response);
1601 /// Ok(())
1602 /// }
1603 /// ```
1604 pub fn create_workflow_invocation(&self) -> super::builder::dataform::CreateWorkflowInvocation {
1605 super::builder::dataform::CreateWorkflowInvocation::new(self.inner.clone())
1606 }
1607
1608 /// Deletes a single WorkflowInvocation.
1609 ///
1610 /// # Example
1611 /// ```
1612 /// # use google_cloud_dataform_v1::client::Dataform;
1613 /// use google_cloud_dataform_v1::Result;
1614 /// async fn sample(
1615 /// client: &Dataform, project_id: &str, location_id: &str, repository_id: &str, workflow_invocation_id: &str
1616 /// ) -> Result<()> {
1617 /// client.delete_workflow_invocation()
1618 /// .set_name(format!("projects/{project_id}/locations/{location_id}/repositories/{repository_id}/workflowInvocations/{workflow_invocation_id}"))
1619 /// .send().await?;
1620 /// Ok(())
1621 /// }
1622 /// ```
1623 pub fn delete_workflow_invocation(&self) -> super::builder::dataform::DeleteWorkflowInvocation {
1624 super::builder::dataform::DeleteWorkflowInvocation::new(self.inner.clone())
1625 }
1626
1627 /// Requests cancellation of a running WorkflowInvocation.
1628 ///
1629 /// # Example
1630 /// ```
1631 /// # use google_cloud_dataform_v1::client::Dataform;
1632 /// use google_cloud_dataform_v1::Result;
1633 /// async fn sample(
1634 /// client: &Dataform
1635 /// ) -> Result<()> {
1636 /// let response = client.cancel_workflow_invocation()
1637 /// /* set fields */
1638 /// .send().await?;
1639 /// println!("response {:?}", response);
1640 /// Ok(())
1641 /// }
1642 /// ```
1643 pub fn cancel_workflow_invocation(&self) -> super::builder::dataform::CancelWorkflowInvocation {
1644 super::builder::dataform::CancelWorkflowInvocation::new(self.inner.clone())
1645 }
1646
1647 /// Returns WorkflowInvocationActions in a given WorkflowInvocation.
1648 ///
1649 /// # Example
1650 /// ```
1651 /// # use google_cloud_dataform_v1::client::Dataform;
1652 /// use google_cloud_gax::paginator::ItemPaginator as _;
1653 /// use google_cloud_dataform_v1::Result;
1654 /// async fn sample(
1655 /// client: &Dataform
1656 /// ) -> Result<()> {
1657 /// let mut list = client.query_workflow_invocation_actions()
1658 /// /* set fields */
1659 /// .by_item();
1660 /// while let Some(item) = list.next().await.transpose()? {
1661 /// println!("{:?}", item);
1662 /// }
1663 /// Ok(())
1664 /// }
1665 /// ```
1666 pub fn query_workflow_invocation_actions(
1667 &self,
1668 ) -> super::builder::dataform::QueryWorkflowInvocationActions {
1669 super::builder::dataform::QueryWorkflowInvocationActions::new(self.inner.clone())
1670 }
1671
1672 /// Get default config for a given project and location.
1673 ///
1674 /// # Example
1675 /// ```
1676 /// # use google_cloud_dataform_v1::client::Dataform;
1677 /// use google_cloud_dataform_v1::Result;
1678 /// async fn sample(
1679 /// client: &Dataform, project_id: &str, location_id: &str
1680 /// ) -> Result<()> {
1681 /// let response = client.get_config()
1682 /// .set_name(format!("projects/{project_id}/locations/{location_id}/config"))
1683 /// .send().await?;
1684 /// println!("response {:?}", response);
1685 /// Ok(())
1686 /// }
1687 /// ```
1688 pub fn get_config(&self) -> super::builder::dataform::GetConfig {
1689 super::builder::dataform::GetConfig::new(self.inner.clone())
1690 }
1691
1692 /// Update default config for a given project and location.
1693 ///
1694 /// **Note:** *This method does not fully implement
1695 /// [AIP/134](https://google.aip.dev/134). The wildcard entry (\*) is treated
1696 /// as a bad request, and when the `field_mask` is omitted, the request is
1697 /// treated as a full update on all modifiable fields.*
1698 ///
1699 /// # Example
1700 /// ```
1701 /// # use google_cloud_dataform_v1::client::Dataform;
1702 /// # extern crate wkt as google_cloud_wkt;
1703 /// use google_cloud_wkt::FieldMask;
1704 /// use google_cloud_dataform_v1::model::Config;
1705 /// use google_cloud_dataform_v1::Result;
1706 /// async fn sample(
1707 /// client: &Dataform, project_id: &str, location_id: &str
1708 /// ) -> Result<()> {
1709 /// let response = client.update_config()
1710 /// .set_config(
1711 /// Config::new().set_name(format!("projects/{project_id}/locations/{location_id}/config"))/* set fields */
1712 /// )
1713 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
1714 /// .send().await?;
1715 /// println!("response {:?}", response);
1716 /// Ok(())
1717 /// }
1718 /// ```
1719 pub fn update_config(&self) -> super::builder::dataform::UpdateConfig {
1720 super::builder::dataform::UpdateConfig::new(self.inner.clone())
1721 }
1722
1723 /// Gets the access control policy for a resource.
1724 /// Returns an empty policy if the resource exists and does not have a policy
1725 /// set.
1726 ///
1727 /// # Example
1728 /// ```
1729 /// # use google_cloud_dataform_v1::client::Dataform;
1730 /// use google_cloud_dataform_v1::Result;
1731 /// async fn sample(
1732 /// client: &Dataform
1733 /// ) -> Result<()> {
1734 /// let response = client.get_iam_policy()
1735 /// /* set fields */
1736 /// .send().await?;
1737 /// println!("response {:?}", response);
1738 /// Ok(())
1739 /// }
1740 /// ```
1741 pub fn get_iam_policy(&self) -> super::builder::dataform::GetIamPolicy {
1742 super::builder::dataform::GetIamPolicy::new(self.inner.clone())
1743 }
1744
1745 /// Sets the access control policy on the specified resource. Replaces any
1746 /// existing policy.
1747 ///
1748 /// Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
1749 ///
1750 /// # Example
1751 /// ```
1752 /// # use google_cloud_dataform_v1::client::Dataform;
1753 /// use google_cloud_dataform_v1::Result;
1754 /// async fn sample(
1755 /// client: &Dataform
1756 /// ) -> Result<()> {
1757 /// let response = client.set_iam_policy()
1758 /// /* set fields */
1759 /// .send().await?;
1760 /// println!("response {:?}", response);
1761 /// Ok(())
1762 /// }
1763 /// ```
1764 pub fn set_iam_policy(&self) -> super::builder::dataform::SetIamPolicy {
1765 super::builder::dataform::SetIamPolicy::new(self.inner.clone())
1766 }
1767
1768 /// Returns permissions that a caller has on the specified resource.
1769 /// If the resource does not exist, this will return an empty set of
1770 /// permissions, not a `NOT_FOUND` error.
1771 ///
1772 /// Note: This operation is designed to be used for building permission-aware
1773 /// UIs and command-line tools, not for authorization checking. This operation
1774 /// may "fail open" without warning.
1775 ///
1776 /// # Example
1777 /// ```
1778 /// # use google_cloud_dataform_v1::client::Dataform;
1779 /// use google_cloud_dataform_v1::Result;
1780 /// async fn sample(
1781 /// client: &Dataform
1782 /// ) -> Result<()> {
1783 /// let response = client.test_iam_permissions()
1784 /// /* set fields */
1785 /// .send().await?;
1786 /// println!("response {:?}", response);
1787 /// Ok(())
1788 /// }
1789 /// ```
1790 pub fn test_iam_permissions(&self) -> super::builder::dataform::TestIamPermissions {
1791 super::builder::dataform::TestIamPermissions::new(self.inner.clone())
1792 }
1793
1794 /// Lists information about the supported locations for this service.
1795 ///
1796 /// This method lists locations based on the resource scope provided in
1797 /// the [ListLocationsRequest.name][google.cloud.location.ListLocationsRequest.name] field: *
1798 /// **Global locations**: If `name` is empty, the method lists the
1799 /// public locations available to all projects. * **Project-specific
1800 /// locations**: If `name` follows the format
1801 /// `projects/{project}`, the method lists locations visible to that
1802 /// specific project. This includes public, private, or other
1803 /// project-specific locations enabled for the project.
1804 ///
1805 /// For gRPC and client library implementations, the resource name is
1806 /// passed as the `name` field. For direct service calls, the resource
1807 /// name is
1808 /// incorporated into the request path based on the specific service
1809 /// implementation and version.
1810 ///
1811 /// [google.cloud.location.ListLocationsRequest.name]: google_cloud_location::model::ListLocationsRequest::name
1812 ///
1813 /// # Example
1814 /// ```
1815 /// # use google_cloud_dataform_v1::client::Dataform;
1816 /// use google_cloud_gax::paginator::ItemPaginator as _;
1817 /// use google_cloud_dataform_v1::Result;
1818 /// async fn sample(
1819 /// client: &Dataform
1820 /// ) -> Result<()> {
1821 /// let mut list = client.list_locations()
1822 /// /* set fields */
1823 /// .by_item();
1824 /// while let Some(item) = list.next().await.transpose()? {
1825 /// println!("{:?}", item);
1826 /// }
1827 /// Ok(())
1828 /// }
1829 /// ```
1830 pub fn list_locations(&self) -> super::builder::dataform::ListLocations {
1831 super::builder::dataform::ListLocations::new(self.inner.clone())
1832 }
1833
1834 /// Gets information about a location.
1835 ///
1836 /// # Example
1837 /// ```
1838 /// # use google_cloud_dataform_v1::client::Dataform;
1839 /// use google_cloud_dataform_v1::Result;
1840 /// async fn sample(
1841 /// client: &Dataform
1842 /// ) -> Result<()> {
1843 /// let response = client.get_location()
1844 /// /* set fields */
1845 /// .send().await?;
1846 /// println!("response {:?}", response);
1847 /// Ok(())
1848 /// }
1849 /// ```
1850 pub fn get_location(&self) -> super::builder::dataform::GetLocation {
1851 super::builder::dataform::GetLocation::new(self.inner.clone())
1852 }
1853
1854 /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
1855 ///
1856 /// [google.longrunning.Operations]: google-cloud-longrunning::client::Operations
1857 ///
1858 /// # Example
1859 /// ```
1860 /// # use google_cloud_dataform_v1::client::Dataform;
1861 /// use google_cloud_gax::paginator::ItemPaginator as _;
1862 /// use google_cloud_dataform_v1::Result;
1863 /// async fn sample(
1864 /// client: &Dataform
1865 /// ) -> Result<()> {
1866 /// let mut list = client.list_operations()
1867 /// /* set fields */
1868 /// .by_item();
1869 /// while let Some(item) = list.next().await.transpose()? {
1870 /// println!("{:?}", item);
1871 /// }
1872 /// Ok(())
1873 /// }
1874 /// ```
1875 pub fn list_operations(&self) -> super::builder::dataform::ListOperations {
1876 super::builder::dataform::ListOperations::new(self.inner.clone())
1877 }
1878
1879 /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
1880 ///
1881 /// [google.longrunning.Operations]: google-cloud-longrunning::client::Operations
1882 ///
1883 /// # Example
1884 /// ```
1885 /// # use google_cloud_dataform_v1::client::Dataform;
1886 /// use google_cloud_dataform_v1::Result;
1887 /// async fn sample(
1888 /// client: &Dataform
1889 /// ) -> Result<()> {
1890 /// let response = client.get_operation()
1891 /// /* set fields */
1892 /// .send().await?;
1893 /// println!("response {:?}", response);
1894 /// Ok(())
1895 /// }
1896 /// ```
1897 pub fn get_operation(&self) -> super::builder::dataform::GetOperation {
1898 super::builder::dataform::GetOperation::new(self.inner.clone())
1899 }
1900
1901 /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
1902 ///
1903 /// [google.longrunning.Operations]: google-cloud-longrunning::client::Operations
1904 ///
1905 /// # Example
1906 /// ```
1907 /// # use google_cloud_dataform_v1::client::Dataform;
1908 /// use google_cloud_dataform_v1::Result;
1909 /// async fn sample(
1910 /// client: &Dataform
1911 /// ) -> Result<()> {
1912 /// client.delete_operation()
1913 /// /* set fields */
1914 /// .send().await?;
1915 /// Ok(())
1916 /// }
1917 /// ```
1918 pub fn delete_operation(&self) -> super::builder::dataform::DeleteOperation {
1919 super::builder::dataform::DeleteOperation::new(self.inner.clone())
1920 }
1921
1922 /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
1923 ///
1924 /// [google.longrunning.Operations]: google-cloud-longrunning::client::Operations
1925 ///
1926 /// # Example
1927 /// ```
1928 /// # use google_cloud_dataform_v1::client::Dataform;
1929 /// use google_cloud_dataform_v1::Result;
1930 /// async fn sample(
1931 /// client: &Dataform
1932 /// ) -> Result<()> {
1933 /// client.cancel_operation()
1934 /// /* set fields */
1935 /// .send().await?;
1936 /// Ok(())
1937 /// }
1938 /// ```
1939 pub fn cancel_operation(&self) -> super::builder::dataform::CancelOperation {
1940 super::builder::dataform::CancelOperation::new(self.inner.clone())
1941 }
1942}