Skip to main content

unitycatalog_client/codegen/temporary_credentials/
builders.rs

1// @generated — do not edit by hand.
2#![allow(unused_mut)]
3#![allow(unused_imports)]
4type BoxFut<'a, T> = ::futures::future::BoxFuture<'a, T>;
5use super::client::*;
6use crate::Result;
7use std::future::IntoFuture;
8use unitycatalog_common::models::temporary_credentials::v1::*;
9/// Builder for temporary table credentials
10pub struct GenerateTemporaryTableCredentialsBuilder {
11    client: TemporaryCredentialClient,
12    request: GenerateTemporaryTableCredentialsRequest,
13}
14impl GenerateTemporaryTableCredentialsBuilder {
15    /// Create a new builder instance.
16    /// Obtain via the corresponding method on `TemporaryCredentialClient`.
17    pub(crate) fn new(
18        client: TemporaryCredentialClient,
19        table_id: impl Into<String>,
20        operation: generate_temporary_table_credentials_request::Operation,
21    ) -> Self {
22        let request = GenerateTemporaryTableCredentialsRequest {
23            table_id: table_id.into(),
24            operation: operation as i32,
25        };
26        Self { client, request }
27    }
28}
29impl IntoFuture for GenerateTemporaryTableCredentialsBuilder {
30    type Output = Result<TemporaryCredential>;
31    type IntoFuture = BoxFut<'static, Self::Output>;
32    fn into_future(self) -> Self::IntoFuture {
33        let client = self.client;
34        let request = self.request;
35        Box::pin(async move { client.generate_temporary_table_credentials(&request).await })
36    }
37}
38/// Builder for temporary path credentials
39pub struct GenerateTemporaryPathCredentialsBuilder {
40    client: TemporaryCredentialClient,
41    request: GenerateTemporaryPathCredentialsRequest,
42}
43impl GenerateTemporaryPathCredentialsBuilder {
44    /// Create a new builder instance.
45    /// Obtain via the corresponding method on `TemporaryCredentialClient`.
46    pub(crate) fn new(
47        client: TemporaryCredentialClient,
48        url: impl Into<String>,
49        operation: generate_temporary_path_credentials_request::Operation,
50    ) -> Self {
51        let request = GenerateTemporaryPathCredentialsRequest {
52            url: url.into(),
53            operation: operation as i32,
54            ..Default::default()
55        };
56        Self { client, request }
57    }
58    /** When set to true, the service will not validate that the generated
59    credentials can perform write operations, therefore no new paths will be
60    created and the response will not contain valid credentials. Defaults to false.*/
61    pub fn with_dry_run(mut self, dry_run: impl Into<Option<bool>>) -> Self {
62        self.request.dry_run = dry_run.into();
63        self
64    }
65}
66impl IntoFuture for GenerateTemporaryPathCredentialsBuilder {
67    type Output = Result<TemporaryCredential>;
68    type IntoFuture = BoxFut<'static, Self::Output>;
69    fn into_future(self) -> Self::IntoFuture {
70        let client = self.client;
71        let request = self.request;
72        Box::pin(async move { client.generate_temporary_path_credentials(&request).await })
73    }
74}
75/// Builder for temporary volume credentials
76pub struct GenerateTemporaryVolumeCredentialsBuilder {
77    client: TemporaryCredentialClient,
78    request: GenerateTemporaryVolumeCredentialsRequest,
79}
80impl GenerateTemporaryVolumeCredentialsBuilder {
81    /// Create a new builder instance.
82    /// Obtain via the corresponding method on `TemporaryCredentialClient`.
83    pub(crate) fn new(
84        client: TemporaryCredentialClient,
85        volume_id: impl Into<String>,
86        operation: generate_temporary_volume_credentials_request::Operation,
87    ) -> Self {
88        let request = GenerateTemporaryVolumeCredentialsRequest {
89            volume_id: volume_id.into(),
90            operation: operation as i32,
91        };
92        Self { client, request }
93    }
94}
95impl IntoFuture for GenerateTemporaryVolumeCredentialsBuilder {
96    type Output = Result<TemporaryCredential>;
97    type IntoFuture = BoxFut<'static, Self::Output>;
98    fn into_future(self) -> Self::IntoFuture {
99        let client = self.client;
100        let request = self.request;
101        Box::pin(async move { client.generate_temporary_volume_credentials(&request).await })
102    }
103}