bitwarden_api_api/apis/
organization_domain_api.rs

1/*
2 * Bitwarden Internal API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: latest
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use std::sync::Arc;
12
13use async_trait::async_trait;
14#[cfg(feature = "mockall")]
15use mockall::automock;
16use reqwest;
17use serde::{Deserialize, Serialize, de::Error as _};
18
19use super::{Error, configuration};
20use crate::{
21    apis::{ContentType, ResponseContent},
22    models,
23};
24
25#[cfg_attr(feature = "mockall", automock)]
26#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
27#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
28pub trait OrganizationDomainApi: Send + Sync {
29    /// GET /organizations/{orgId}/domain/{id}
30    async fn get<'a>(
31        &self,
32        org_id: uuid::Uuid,
33        id: uuid::Uuid,
34    ) -> Result<models::OrganizationDomainResponseModel, Error<GetError>>;
35
36    /// GET /organizations/{orgId}/domain
37    async fn get_all<'a>(
38        &self,
39        org_id: uuid::Uuid,
40    ) -> Result<models::OrganizationDomainResponseModelListResponseModel, Error<GetAllError>>;
41
42    /// POST /organizations/domain/sso/details
43    async fn get_org_domain_sso_details<'a>(
44        &self,
45        organization_domain_sso_details_request_model: Option<
46            models::OrganizationDomainSsoDetailsRequestModel,
47        >,
48    ) -> Result<models::OrganizationDomainSsoDetailsResponseModel, Error<GetOrgDomainSsoDetailsError>>;
49
50    /// POST /organizations/domain/sso/verified
51    async fn get_verified_org_domain_sso_details<'a>(
52        &self,
53        organization_domain_sso_details_request_model: Option<
54            models::OrganizationDomainSsoDetailsRequestModel,
55        >,
56    ) -> Result<
57        models::VerifiedOrganizationDomainSsoDetailsResponseModel,
58        Error<GetVerifiedOrgDomainSsoDetailsError>,
59    >;
60
61    /// POST /organizations/{orgId}/domain
62    async fn post<'a>(
63        &self,
64        org_id: uuid::Uuid,
65        organization_domain_request_model: Option<models::OrganizationDomainRequestModel>,
66    ) -> Result<models::OrganizationDomainResponseModel, Error<PostError>>;
67
68    /// DELETE /organizations/{orgId}/domain/{id}
69    async fn remove_domain<'a>(
70        &self,
71        org_id: uuid::Uuid,
72        id: uuid::Uuid,
73    ) -> Result<(), Error<RemoveDomainError>>;
74
75    /// POST /organizations/{orgId}/domain/{id}/verify
76    async fn verify<'a>(
77        &self,
78        org_id: uuid::Uuid,
79        id: uuid::Uuid,
80    ) -> Result<models::OrganizationDomainResponseModel, Error<VerifyError>>;
81}
82
83pub struct OrganizationDomainApiClient {
84    configuration: Arc<configuration::Configuration>,
85}
86
87impl OrganizationDomainApiClient {
88    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
89        Self { configuration }
90    }
91}
92
93#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
94#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
95impl OrganizationDomainApi for OrganizationDomainApiClient {
96    async fn get<'a>(
97        &self,
98        org_id: uuid::Uuid,
99        id: uuid::Uuid,
100    ) -> Result<models::OrganizationDomainResponseModel, Error<GetError>> {
101        let local_var_configuration = &self.configuration;
102
103        let local_var_client = &local_var_configuration.client;
104
105        let local_var_uri_str = format!(
106            "{}/organizations/{orgId}/domain/{id}",
107            local_var_configuration.base_path,
108            orgId = org_id,
109            id = id
110        );
111        let mut local_var_req_builder =
112            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
113
114        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
115            local_var_req_builder = local_var_req_builder
116                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
117        }
118        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
119            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
120        };
121
122        let local_var_req = local_var_req_builder.build()?;
123        let local_var_resp = local_var_client.execute(local_var_req).await?;
124
125        let local_var_status = local_var_resp.status();
126        let local_var_content_type = local_var_resp
127            .headers()
128            .get("content-type")
129            .and_then(|v| v.to_str().ok())
130            .unwrap_or("application/octet-stream");
131        let local_var_content_type = super::ContentType::from(local_var_content_type);
132        let local_var_content = local_var_resp.text().await?;
133
134        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
135            match local_var_content_type {
136                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
137                ContentType::Text => {
138                    return Err(Error::from(serde_json::Error::custom(
139                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationDomainResponseModel`",
140                    )));
141                }
142                ContentType::Unsupported(local_var_unknown_type) => {
143                    return Err(Error::from(serde_json::Error::custom(format!(
144                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationDomainResponseModel`"
145                    ))));
146                }
147            }
148        } else {
149            let local_var_entity: Option<GetError> = serde_json::from_str(&local_var_content).ok();
150            let local_var_error = ResponseContent {
151                status: local_var_status,
152                content: local_var_content,
153                entity: local_var_entity,
154            };
155            Err(Error::ResponseError(local_var_error))
156        }
157    }
158
159    async fn get_all<'a>(
160        &self,
161        org_id: uuid::Uuid,
162    ) -> Result<models::OrganizationDomainResponseModelListResponseModel, Error<GetAllError>> {
163        let local_var_configuration = &self.configuration;
164
165        let local_var_client = &local_var_configuration.client;
166
167        let local_var_uri_str = format!(
168            "{}/organizations/{orgId}/domain",
169            local_var_configuration.base_path,
170            orgId = org_id
171        );
172        let mut local_var_req_builder =
173            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
174
175        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
176            local_var_req_builder = local_var_req_builder
177                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
178        }
179        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
180            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
181        };
182
183        let local_var_req = local_var_req_builder.build()?;
184        let local_var_resp = local_var_client.execute(local_var_req).await?;
185
186        let local_var_status = local_var_resp.status();
187        let local_var_content_type = local_var_resp
188            .headers()
189            .get("content-type")
190            .and_then(|v| v.to_str().ok())
191            .unwrap_or("application/octet-stream");
192        let local_var_content_type = super::ContentType::from(local_var_content_type);
193        let local_var_content = local_var_resp.text().await?;
194
195        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
196            match local_var_content_type {
197                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
198                ContentType::Text => {
199                    return Err(Error::from(serde_json::Error::custom(
200                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationDomainResponseModelListResponseModel`",
201                    )));
202                }
203                ContentType::Unsupported(local_var_unknown_type) => {
204                    return Err(Error::from(serde_json::Error::custom(format!(
205                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationDomainResponseModelListResponseModel`"
206                    ))));
207                }
208            }
209        } else {
210            let local_var_entity: Option<GetAllError> =
211                serde_json::from_str(&local_var_content).ok();
212            let local_var_error = ResponseContent {
213                status: local_var_status,
214                content: local_var_content,
215                entity: local_var_entity,
216            };
217            Err(Error::ResponseError(local_var_error))
218        }
219    }
220
221    async fn get_org_domain_sso_details<'a>(
222        &self,
223        organization_domain_sso_details_request_model: Option<
224            models::OrganizationDomainSsoDetailsRequestModel,
225        >,
226    ) -> Result<models::OrganizationDomainSsoDetailsResponseModel, Error<GetOrgDomainSsoDetailsError>>
227    {
228        let local_var_configuration = &self.configuration;
229
230        let local_var_client = &local_var_configuration.client;
231
232        let local_var_uri_str = format!(
233            "{}/organizations/domain/sso/details",
234            local_var_configuration.base_path
235        );
236        let mut local_var_req_builder =
237            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
238
239        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
240            local_var_req_builder = local_var_req_builder
241                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
242        }
243        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
244            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
245        };
246        local_var_req_builder =
247            local_var_req_builder.json(&organization_domain_sso_details_request_model);
248
249        let local_var_req = local_var_req_builder.build()?;
250        let local_var_resp = local_var_client.execute(local_var_req).await?;
251
252        let local_var_status = local_var_resp.status();
253        let local_var_content_type = local_var_resp
254            .headers()
255            .get("content-type")
256            .and_then(|v| v.to_str().ok())
257            .unwrap_or("application/octet-stream");
258        let local_var_content_type = super::ContentType::from(local_var_content_type);
259        let local_var_content = local_var_resp.text().await?;
260
261        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
262            match local_var_content_type {
263                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
264                ContentType::Text => {
265                    return Err(Error::from(serde_json::Error::custom(
266                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationDomainSsoDetailsResponseModel`",
267                    )));
268                }
269                ContentType::Unsupported(local_var_unknown_type) => {
270                    return Err(Error::from(serde_json::Error::custom(format!(
271                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationDomainSsoDetailsResponseModel`"
272                    ))));
273                }
274            }
275        } else {
276            let local_var_entity: Option<GetOrgDomainSsoDetailsError> =
277                serde_json::from_str(&local_var_content).ok();
278            let local_var_error = ResponseContent {
279                status: local_var_status,
280                content: local_var_content,
281                entity: local_var_entity,
282            };
283            Err(Error::ResponseError(local_var_error))
284        }
285    }
286
287    async fn get_verified_org_domain_sso_details<'a>(
288        &self,
289        organization_domain_sso_details_request_model: Option<
290            models::OrganizationDomainSsoDetailsRequestModel,
291        >,
292    ) -> Result<
293        models::VerifiedOrganizationDomainSsoDetailsResponseModel,
294        Error<GetVerifiedOrgDomainSsoDetailsError>,
295    > {
296        let local_var_configuration = &self.configuration;
297
298        let local_var_client = &local_var_configuration.client;
299
300        let local_var_uri_str = format!(
301            "{}/organizations/domain/sso/verified",
302            local_var_configuration.base_path
303        );
304        let mut local_var_req_builder =
305            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
306
307        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
308            local_var_req_builder = local_var_req_builder
309                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
310        }
311        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
312            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
313        };
314        local_var_req_builder =
315            local_var_req_builder.json(&organization_domain_sso_details_request_model);
316
317        let local_var_req = local_var_req_builder.build()?;
318        let local_var_resp = local_var_client.execute(local_var_req).await?;
319
320        let local_var_status = local_var_resp.status();
321        let local_var_content_type = local_var_resp
322            .headers()
323            .get("content-type")
324            .and_then(|v| v.to_str().ok())
325            .unwrap_or("application/octet-stream");
326        let local_var_content_type = super::ContentType::from(local_var_content_type);
327        let local_var_content = local_var_resp.text().await?;
328
329        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
330            match local_var_content_type {
331                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
332                ContentType::Text => {
333                    return Err(Error::from(serde_json::Error::custom(
334                        "Received `text/plain` content type response that cannot be converted to `models::VerifiedOrganizationDomainSsoDetailsResponseModel`",
335                    )));
336                }
337                ContentType::Unsupported(local_var_unknown_type) => {
338                    return Err(Error::from(serde_json::Error::custom(format!(
339                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::VerifiedOrganizationDomainSsoDetailsResponseModel`"
340                    ))));
341                }
342            }
343        } else {
344            let local_var_entity: Option<GetVerifiedOrgDomainSsoDetailsError> =
345                serde_json::from_str(&local_var_content).ok();
346            let local_var_error = ResponseContent {
347                status: local_var_status,
348                content: local_var_content,
349                entity: local_var_entity,
350            };
351            Err(Error::ResponseError(local_var_error))
352        }
353    }
354
355    async fn post<'a>(
356        &self,
357        org_id: uuid::Uuid,
358        organization_domain_request_model: Option<models::OrganizationDomainRequestModel>,
359    ) -> Result<models::OrganizationDomainResponseModel, Error<PostError>> {
360        let local_var_configuration = &self.configuration;
361
362        let local_var_client = &local_var_configuration.client;
363
364        let local_var_uri_str = format!(
365            "{}/organizations/{orgId}/domain",
366            local_var_configuration.base_path,
367            orgId = org_id
368        );
369        let mut local_var_req_builder =
370            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
371
372        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
373            local_var_req_builder = local_var_req_builder
374                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
375        }
376        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
377            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
378        };
379        local_var_req_builder = local_var_req_builder.json(&organization_domain_request_model);
380
381        let local_var_req = local_var_req_builder.build()?;
382        let local_var_resp = local_var_client.execute(local_var_req).await?;
383
384        let local_var_status = local_var_resp.status();
385        let local_var_content_type = local_var_resp
386            .headers()
387            .get("content-type")
388            .and_then(|v| v.to_str().ok())
389            .unwrap_or("application/octet-stream");
390        let local_var_content_type = super::ContentType::from(local_var_content_type);
391        let local_var_content = local_var_resp.text().await?;
392
393        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
394            match local_var_content_type {
395                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
396                ContentType::Text => {
397                    return Err(Error::from(serde_json::Error::custom(
398                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationDomainResponseModel`",
399                    )));
400                }
401                ContentType::Unsupported(local_var_unknown_type) => {
402                    return Err(Error::from(serde_json::Error::custom(format!(
403                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationDomainResponseModel`"
404                    ))));
405                }
406            }
407        } else {
408            let local_var_entity: Option<PostError> = serde_json::from_str(&local_var_content).ok();
409            let local_var_error = ResponseContent {
410                status: local_var_status,
411                content: local_var_content,
412                entity: local_var_entity,
413            };
414            Err(Error::ResponseError(local_var_error))
415        }
416    }
417
418    async fn remove_domain<'a>(
419        &self,
420        org_id: uuid::Uuid,
421        id: uuid::Uuid,
422    ) -> Result<(), Error<RemoveDomainError>> {
423        let local_var_configuration = &self.configuration;
424
425        let local_var_client = &local_var_configuration.client;
426
427        let local_var_uri_str = format!(
428            "{}/organizations/{orgId}/domain/{id}",
429            local_var_configuration.base_path,
430            orgId = org_id,
431            id = id
432        );
433        let mut local_var_req_builder =
434            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
435
436        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
437            local_var_req_builder = local_var_req_builder
438                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
439        }
440        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
441            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
442        };
443
444        let local_var_req = local_var_req_builder.build()?;
445        let local_var_resp = local_var_client.execute(local_var_req).await?;
446
447        let local_var_status = local_var_resp.status();
448        let local_var_content = local_var_resp.text().await?;
449
450        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
451            Ok(())
452        } else {
453            let local_var_entity: Option<RemoveDomainError> =
454                serde_json::from_str(&local_var_content).ok();
455            let local_var_error = ResponseContent {
456                status: local_var_status,
457                content: local_var_content,
458                entity: local_var_entity,
459            };
460            Err(Error::ResponseError(local_var_error))
461        }
462    }
463
464    async fn verify<'a>(
465        &self,
466        org_id: uuid::Uuid,
467        id: uuid::Uuid,
468    ) -> Result<models::OrganizationDomainResponseModel, Error<VerifyError>> {
469        let local_var_configuration = &self.configuration;
470
471        let local_var_client = &local_var_configuration.client;
472
473        let local_var_uri_str = format!(
474            "{}/organizations/{orgId}/domain/{id}/verify",
475            local_var_configuration.base_path,
476            orgId = org_id,
477            id = id
478        );
479        let mut local_var_req_builder =
480            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
481
482        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
483            local_var_req_builder = local_var_req_builder
484                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
485        }
486        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
487            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
488        };
489
490        let local_var_req = local_var_req_builder.build()?;
491        let local_var_resp = local_var_client.execute(local_var_req).await?;
492
493        let local_var_status = local_var_resp.status();
494        let local_var_content_type = local_var_resp
495            .headers()
496            .get("content-type")
497            .and_then(|v| v.to_str().ok())
498            .unwrap_or("application/octet-stream");
499        let local_var_content_type = super::ContentType::from(local_var_content_type);
500        let local_var_content = local_var_resp.text().await?;
501
502        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
503            match local_var_content_type {
504                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
505                ContentType::Text => {
506                    return Err(Error::from(serde_json::Error::custom(
507                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationDomainResponseModel`",
508                    )));
509                }
510                ContentType::Unsupported(local_var_unknown_type) => {
511                    return Err(Error::from(serde_json::Error::custom(format!(
512                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationDomainResponseModel`"
513                    ))));
514                }
515            }
516        } else {
517            let local_var_entity: Option<VerifyError> =
518                serde_json::from_str(&local_var_content).ok();
519            let local_var_error = ResponseContent {
520                status: local_var_status,
521                content: local_var_content,
522                entity: local_var_entity,
523            };
524            Err(Error::ResponseError(local_var_error))
525        }
526    }
527}
528
529/// struct for typed errors of method [`OrganizationDomainApi::get`]
530#[derive(Debug, Clone, Serialize, Deserialize)]
531#[serde(untagged)]
532pub enum GetError {
533    UnknownValue(serde_json::Value),
534}
535/// struct for typed errors of method [`OrganizationDomainApi::get_all`]
536#[derive(Debug, Clone, Serialize, Deserialize)]
537#[serde(untagged)]
538pub enum GetAllError {
539    UnknownValue(serde_json::Value),
540}
541/// struct for typed errors of method [`OrganizationDomainApi::get_org_domain_sso_details`]
542#[derive(Debug, Clone, Serialize, Deserialize)]
543#[serde(untagged)]
544pub enum GetOrgDomainSsoDetailsError {
545    UnknownValue(serde_json::Value),
546}
547/// struct for typed errors of method [`OrganizationDomainApi::get_verified_org_domain_sso_details`]
548#[derive(Debug, Clone, Serialize, Deserialize)]
549#[serde(untagged)]
550pub enum GetVerifiedOrgDomainSsoDetailsError {
551    UnknownValue(serde_json::Value),
552}
553/// struct for typed errors of method [`OrganizationDomainApi::post`]
554#[derive(Debug, Clone, Serialize, Deserialize)]
555#[serde(untagged)]
556pub enum PostError {
557    UnknownValue(serde_json::Value),
558}
559/// struct for typed errors of method [`OrganizationDomainApi::remove_domain`]
560#[derive(Debug, Clone, Serialize, Deserialize)]
561#[serde(untagged)]
562pub enum RemoveDomainError {
563    UnknownValue(serde_json::Value),
564}
565/// struct for typed errors of method [`OrganizationDomainApi::verify`]
566#[derive(Debug, Clone, Serialize, Deserialize)]
567#[serde(untagged)]
568pub enum VerifyError {
569    UnknownValue(serde_json::Value),
570}
bitwarden_api_api/apis/organization_domain_api.rs

bitwarden_api_api/apis/
organization_domain_api.rs
