bitwarden_api_api/apis/
provider_users_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::{AuthRequired, 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 ProviderUsersApi: Send + Sync {
29    /// POST /providers/{providerId}/users/{id}/accept
30    async fn accept<'a>(
31        &self,
32        provider_id: uuid::Uuid,
33        id: uuid::Uuid,
34        provider_user_accept_request_model: Option<models::ProviderUserAcceptRequestModel>,
35    ) -> Result<(), Error<AcceptError>>;
36
37    /// POST /providers/{providerId}/users/confirm
38    async fn bulk_confirm<'a>(
39        &self,
40        provider_id: uuid::Uuid,
41        provider_user_bulk_confirm_request_model: Option<
42            models::ProviderUserBulkConfirmRequestModel,
43        >,
44    ) -> Result<models::ProviderUserBulkResponseModelListResponseModel, Error<BulkConfirmError>>;
45
46    /// DELETE /providers/{providerId}/users
47    async fn bulk_delete<'a>(
48        &self,
49        provider_id: uuid::Uuid,
50        provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
51    ) -> Result<models::ProviderUserBulkResponseModelListResponseModel, Error<BulkDeleteError>>;
52
53    /// POST /providers/{providerId}/users/reinvite
54    async fn bulk_reinvite<'a>(
55        &self,
56        provider_id: uuid::Uuid,
57        provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
58    ) -> Result<models::ProviderUserBulkResponseModelListResponseModel, Error<BulkReinviteError>>;
59
60    /// POST /providers/{providerId}/users/{id}/confirm
61    async fn confirm<'a>(
62        &self,
63        provider_id: uuid::Uuid,
64        id: uuid::Uuid,
65        provider_user_confirm_request_model: Option<models::ProviderUserConfirmRequestModel>,
66    ) -> Result<(), Error<ConfirmError>>;
67
68    /// DELETE /providers/{providerId}/users/{id}
69    async fn delete<'a>(
70        &self,
71        provider_id: uuid::Uuid,
72        id: uuid::Uuid,
73    ) -> Result<(), Error<DeleteError>>;
74
75    /// GET /providers/{providerId}/users/{id}
76    async fn get<'a>(
77        &self,
78        provider_id: uuid::Uuid,
79        id: uuid::Uuid,
80    ) -> Result<models::ProviderUserResponseModel, Error<GetError>>;
81
82    /// GET /providers/{providerId}/users
83    async fn get_all<'a>(
84        &self,
85        provider_id: uuid::Uuid,
86    ) -> Result<models::ProviderUserUserDetailsResponseModelListResponseModel, Error<GetAllError>>;
87
88    /// POST /providers/{providerId}/users/invite
89    async fn invite<'a>(
90        &self,
91        provider_id: uuid::Uuid,
92        provider_user_invite_request_model: Option<models::ProviderUserInviteRequestModel>,
93    ) -> Result<(), Error<InviteError>>;
94
95    /// PUT /providers/{providerId}/users/{id}
96    async fn put<'a>(
97        &self,
98        provider_id: uuid::Uuid,
99        id: uuid::Uuid,
100        provider_user_update_request_model: Option<models::ProviderUserUpdateRequestModel>,
101    ) -> Result<(), Error<PutError>>;
102
103    /// POST /providers/{providerId}/users/{id}/reinvite
104    async fn reinvite<'a>(
105        &self,
106        provider_id: uuid::Uuid,
107        id: uuid::Uuid,
108    ) -> Result<(), Error<ReinviteError>>;
109
110    /// POST /providers/{providerId}/users/public-keys
111    async fn user_public_keys<'a>(
112        &self,
113        provider_id: uuid::Uuid,
114        provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
115    ) -> Result<
116        models::ProviderUserPublicKeyResponseModelListResponseModel,
117        Error<UserPublicKeysError>,
118    >;
119}
120
121pub struct ProviderUsersApiClient {
122    configuration: Arc<configuration::Configuration>,
123}
124
125impl ProviderUsersApiClient {
126    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
127        Self { configuration }
128    }
129}
130
131#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
132#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
133impl ProviderUsersApi for ProviderUsersApiClient {
134    async fn accept<'a>(
135        &self,
136        provider_id: uuid::Uuid,
137        id: uuid::Uuid,
138        provider_user_accept_request_model: Option<models::ProviderUserAcceptRequestModel>,
139    ) -> Result<(), Error<AcceptError>> {
140        let local_var_configuration = &self.configuration;
141
142        let local_var_client = &local_var_configuration.client;
143
144        let local_var_uri_str = format!(
145            "{}/providers/{providerId}/users/{id}/accept",
146            local_var_configuration.base_path,
147            providerId = provider_id,
148            id = id
149        );
150        let mut local_var_req_builder =
151            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
152
153        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
154            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
155        };
156        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
157        local_var_req_builder = local_var_req_builder.json(&provider_user_accept_request_model);
158
159        let local_var_req = local_var_req_builder.build()?;
160        let local_var_resp = local_var_client.execute(local_var_req).await?;
161
162        let local_var_status = local_var_resp.status();
163        let local_var_content = local_var_resp.text().await?;
164
165        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
166            Ok(())
167        } else {
168            let local_var_entity: Option<AcceptError> =
169                serde_json::from_str(&local_var_content).ok();
170            let local_var_error = ResponseContent {
171                status: local_var_status,
172                content: local_var_content,
173                entity: local_var_entity,
174            };
175            Err(Error::ResponseError(local_var_error))
176        }
177    }
178
179    async fn bulk_confirm<'a>(
180        &self,
181        provider_id: uuid::Uuid,
182        provider_user_bulk_confirm_request_model: Option<
183            models::ProviderUserBulkConfirmRequestModel,
184        >,
185    ) -> Result<models::ProviderUserBulkResponseModelListResponseModel, Error<BulkConfirmError>>
186    {
187        let local_var_configuration = &self.configuration;
188
189        let local_var_client = &local_var_configuration.client;
190
191        let local_var_uri_str = format!(
192            "{}/providers/{providerId}/users/confirm",
193            local_var_configuration.base_path,
194            providerId = provider_id
195        );
196        let mut local_var_req_builder =
197            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
198
199        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
200            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
201        };
202        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
203        local_var_req_builder =
204            local_var_req_builder.json(&provider_user_bulk_confirm_request_model);
205
206        let local_var_req = local_var_req_builder.build()?;
207        let local_var_resp = local_var_client.execute(local_var_req).await?;
208
209        let local_var_status = local_var_resp.status();
210        let local_var_content_type = local_var_resp
211            .headers()
212            .get("content-type")
213            .and_then(|v| v.to_str().ok())
214            .unwrap_or("application/octet-stream");
215        let local_var_content_type = super::ContentType::from(local_var_content_type);
216        let local_var_content = local_var_resp.text().await?;
217
218        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
219            match local_var_content_type {
220                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
221                ContentType::Text => {
222                    return Err(Error::from(serde_json::Error::custom(
223                        "Received `text/plain` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`",
224                    )));
225                }
226                ContentType::Unsupported(local_var_unknown_type) => {
227                    return Err(Error::from(serde_json::Error::custom(format!(
228                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`"
229                    ))));
230                }
231            }
232        } else {
233            let local_var_entity: Option<BulkConfirmError> =
234                serde_json::from_str(&local_var_content).ok();
235            let local_var_error = ResponseContent {
236                status: local_var_status,
237                content: local_var_content,
238                entity: local_var_entity,
239            };
240            Err(Error::ResponseError(local_var_error))
241        }
242    }
243
244    async fn bulk_delete<'a>(
245        &self,
246        provider_id: uuid::Uuid,
247        provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
248    ) -> Result<models::ProviderUserBulkResponseModelListResponseModel, Error<BulkDeleteError>>
249    {
250        let local_var_configuration = &self.configuration;
251
252        let local_var_client = &local_var_configuration.client;
253
254        let local_var_uri_str = format!(
255            "{}/providers/{providerId}/users",
256            local_var_configuration.base_path,
257            providerId = provider_id
258        );
259        let mut local_var_req_builder =
260            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
261
262        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
263            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
264        };
265        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
266        local_var_req_builder = local_var_req_builder.json(&provider_user_bulk_request_model);
267
268        let local_var_req = local_var_req_builder.build()?;
269        let local_var_resp = local_var_client.execute(local_var_req).await?;
270
271        let local_var_status = local_var_resp.status();
272        let local_var_content_type = local_var_resp
273            .headers()
274            .get("content-type")
275            .and_then(|v| v.to_str().ok())
276            .unwrap_or("application/octet-stream");
277        let local_var_content_type = super::ContentType::from(local_var_content_type);
278        let local_var_content = local_var_resp.text().await?;
279
280        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
281            match local_var_content_type {
282                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
283                ContentType::Text => {
284                    return Err(Error::from(serde_json::Error::custom(
285                        "Received `text/plain` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`",
286                    )));
287                }
288                ContentType::Unsupported(local_var_unknown_type) => {
289                    return Err(Error::from(serde_json::Error::custom(format!(
290                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`"
291                    ))));
292                }
293            }
294        } else {
295            let local_var_entity: Option<BulkDeleteError> =
296                serde_json::from_str(&local_var_content).ok();
297            let local_var_error = ResponseContent {
298                status: local_var_status,
299                content: local_var_content,
300                entity: local_var_entity,
301            };
302            Err(Error::ResponseError(local_var_error))
303        }
304    }
305
306    async fn bulk_reinvite<'a>(
307        &self,
308        provider_id: uuid::Uuid,
309        provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
310    ) -> Result<models::ProviderUserBulkResponseModelListResponseModel, Error<BulkReinviteError>>
311    {
312        let local_var_configuration = &self.configuration;
313
314        let local_var_client = &local_var_configuration.client;
315
316        let local_var_uri_str = format!(
317            "{}/providers/{providerId}/users/reinvite",
318            local_var_configuration.base_path,
319            providerId = provider_id
320        );
321        let mut local_var_req_builder =
322            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
323
324        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
325            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
326        };
327        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
328        local_var_req_builder = local_var_req_builder.json(&provider_user_bulk_request_model);
329
330        let local_var_req = local_var_req_builder.build()?;
331        let local_var_resp = local_var_client.execute(local_var_req).await?;
332
333        let local_var_status = local_var_resp.status();
334        let local_var_content_type = local_var_resp
335            .headers()
336            .get("content-type")
337            .and_then(|v| v.to_str().ok())
338            .unwrap_or("application/octet-stream");
339        let local_var_content_type = super::ContentType::from(local_var_content_type);
340        let local_var_content = local_var_resp.text().await?;
341
342        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
343            match local_var_content_type {
344                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
345                ContentType::Text => {
346                    return Err(Error::from(serde_json::Error::custom(
347                        "Received `text/plain` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`",
348                    )));
349                }
350                ContentType::Unsupported(local_var_unknown_type) => {
351                    return Err(Error::from(serde_json::Error::custom(format!(
352                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`"
353                    ))));
354                }
355            }
356        } else {
357            let local_var_entity: Option<BulkReinviteError> =
358                serde_json::from_str(&local_var_content).ok();
359            let local_var_error = ResponseContent {
360                status: local_var_status,
361                content: local_var_content,
362                entity: local_var_entity,
363            };
364            Err(Error::ResponseError(local_var_error))
365        }
366    }
367
368    async fn confirm<'a>(
369        &self,
370        provider_id: uuid::Uuid,
371        id: uuid::Uuid,
372        provider_user_confirm_request_model: Option<models::ProviderUserConfirmRequestModel>,
373    ) -> Result<(), Error<ConfirmError>> {
374        let local_var_configuration = &self.configuration;
375
376        let local_var_client = &local_var_configuration.client;
377
378        let local_var_uri_str = format!(
379            "{}/providers/{providerId}/users/{id}/confirm",
380            local_var_configuration.base_path,
381            providerId = provider_id,
382            id = id
383        );
384        let mut local_var_req_builder =
385            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
386
387        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
388            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
389        };
390        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
391        local_var_req_builder = local_var_req_builder.json(&provider_user_confirm_request_model);
392
393        let local_var_req = local_var_req_builder.build()?;
394        let local_var_resp = local_var_client.execute(local_var_req).await?;
395
396        let local_var_status = local_var_resp.status();
397        let local_var_content = local_var_resp.text().await?;
398
399        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
400            Ok(())
401        } else {
402            let local_var_entity: Option<ConfirmError> =
403                serde_json::from_str(&local_var_content).ok();
404            let local_var_error = ResponseContent {
405                status: local_var_status,
406                content: local_var_content,
407                entity: local_var_entity,
408            };
409            Err(Error::ResponseError(local_var_error))
410        }
411    }
412
413    async fn delete<'a>(
414        &self,
415        provider_id: uuid::Uuid,
416        id: uuid::Uuid,
417    ) -> Result<(), Error<DeleteError>> {
418        let local_var_configuration = &self.configuration;
419
420        let local_var_client = &local_var_configuration.client;
421
422        let local_var_uri_str = format!(
423            "{}/providers/{providerId}/users/{id}",
424            local_var_configuration.base_path,
425            providerId = provider_id,
426            id = id
427        );
428        let mut local_var_req_builder =
429            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
430
431        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
432            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
433        };
434        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
435
436        let local_var_req = local_var_req_builder.build()?;
437        let local_var_resp = local_var_client.execute(local_var_req).await?;
438
439        let local_var_status = local_var_resp.status();
440        let local_var_content = local_var_resp.text().await?;
441
442        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
443            Ok(())
444        } else {
445            let local_var_entity: Option<DeleteError> =
446                serde_json::from_str(&local_var_content).ok();
447            let local_var_error = ResponseContent {
448                status: local_var_status,
449                content: local_var_content,
450                entity: local_var_entity,
451            };
452            Err(Error::ResponseError(local_var_error))
453        }
454    }
455
456    async fn get<'a>(
457        &self,
458        provider_id: uuid::Uuid,
459        id: uuid::Uuid,
460    ) -> Result<models::ProviderUserResponseModel, Error<GetError>> {
461        let local_var_configuration = &self.configuration;
462
463        let local_var_client = &local_var_configuration.client;
464
465        let local_var_uri_str = format!(
466            "{}/providers/{providerId}/users/{id}",
467            local_var_configuration.base_path,
468            providerId = provider_id,
469            id = id
470        );
471        let mut local_var_req_builder =
472            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
473
474        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
475            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
476        };
477        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
478
479        let local_var_req = local_var_req_builder.build()?;
480        let local_var_resp = local_var_client.execute(local_var_req).await?;
481
482        let local_var_status = local_var_resp.status();
483        let local_var_content_type = local_var_resp
484            .headers()
485            .get("content-type")
486            .and_then(|v| v.to_str().ok())
487            .unwrap_or("application/octet-stream");
488        let local_var_content_type = super::ContentType::from(local_var_content_type);
489        let local_var_content = local_var_resp.text().await?;
490
491        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
492            match local_var_content_type {
493                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
494                ContentType::Text => {
495                    return Err(Error::from(serde_json::Error::custom(
496                        "Received `text/plain` content type response that cannot be converted to `models::ProviderUserResponseModel`",
497                    )));
498                }
499                ContentType::Unsupported(local_var_unknown_type) => {
500                    return Err(Error::from(serde_json::Error::custom(format!(
501                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderUserResponseModel`"
502                    ))));
503                }
504            }
505        } else {
506            let local_var_entity: Option<GetError> = serde_json::from_str(&local_var_content).ok();
507            let local_var_error = ResponseContent {
508                status: local_var_status,
509                content: local_var_content,
510                entity: local_var_entity,
511            };
512            Err(Error::ResponseError(local_var_error))
513        }
514    }
515
516    async fn get_all<'a>(
517        &self,
518        provider_id: uuid::Uuid,
519    ) -> Result<models::ProviderUserUserDetailsResponseModelListResponseModel, Error<GetAllError>>
520    {
521        let local_var_configuration = &self.configuration;
522
523        let local_var_client = &local_var_configuration.client;
524
525        let local_var_uri_str = format!(
526            "{}/providers/{providerId}/users",
527            local_var_configuration.base_path,
528            providerId = provider_id
529        );
530        let mut local_var_req_builder =
531            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
532
533        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
534            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
535        };
536        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
537
538        let local_var_req = local_var_req_builder.build()?;
539        let local_var_resp = local_var_client.execute(local_var_req).await?;
540
541        let local_var_status = local_var_resp.status();
542        let local_var_content_type = local_var_resp
543            .headers()
544            .get("content-type")
545            .and_then(|v| v.to_str().ok())
546            .unwrap_or("application/octet-stream");
547        let local_var_content_type = super::ContentType::from(local_var_content_type);
548        let local_var_content = local_var_resp.text().await?;
549
550        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
551            match local_var_content_type {
552                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
553                ContentType::Text => {
554                    return Err(Error::from(serde_json::Error::custom(
555                        "Received `text/plain` content type response that cannot be converted to `models::ProviderUserUserDetailsResponseModelListResponseModel`",
556                    )));
557                }
558                ContentType::Unsupported(local_var_unknown_type) => {
559                    return Err(Error::from(serde_json::Error::custom(format!(
560                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderUserUserDetailsResponseModelListResponseModel`"
561                    ))));
562                }
563            }
564        } else {
565            let local_var_entity: Option<GetAllError> =
566                serde_json::from_str(&local_var_content).ok();
567            let local_var_error = ResponseContent {
568                status: local_var_status,
569                content: local_var_content,
570                entity: local_var_entity,
571            };
572            Err(Error::ResponseError(local_var_error))
573        }
574    }
575
576    async fn invite<'a>(
577        &self,
578        provider_id: uuid::Uuid,
579        provider_user_invite_request_model: Option<models::ProviderUserInviteRequestModel>,
580    ) -> Result<(), Error<InviteError>> {
581        let local_var_configuration = &self.configuration;
582
583        let local_var_client = &local_var_configuration.client;
584
585        let local_var_uri_str = format!(
586            "{}/providers/{providerId}/users/invite",
587            local_var_configuration.base_path,
588            providerId = provider_id
589        );
590        let mut local_var_req_builder =
591            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
592
593        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
594            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
595        };
596        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
597        local_var_req_builder = local_var_req_builder.json(&provider_user_invite_request_model);
598
599        let local_var_req = local_var_req_builder.build()?;
600        let local_var_resp = local_var_client.execute(local_var_req).await?;
601
602        let local_var_status = local_var_resp.status();
603        let local_var_content = local_var_resp.text().await?;
604
605        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
606            Ok(())
607        } else {
608            let local_var_entity: Option<InviteError> =
609                serde_json::from_str(&local_var_content).ok();
610            let local_var_error = ResponseContent {
611                status: local_var_status,
612                content: local_var_content,
613                entity: local_var_entity,
614            };
615            Err(Error::ResponseError(local_var_error))
616        }
617    }
618
619    async fn put<'a>(
620        &self,
621        provider_id: uuid::Uuid,
622        id: uuid::Uuid,
623        provider_user_update_request_model: Option<models::ProviderUserUpdateRequestModel>,
624    ) -> Result<(), Error<PutError>> {
625        let local_var_configuration = &self.configuration;
626
627        let local_var_client = &local_var_configuration.client;
628
629        let local_var_uri_str = format!(
630            "{}/providers/{providerId}/users/{id}",
631            local_var_configuration.base_path,
632            providerId = provider_id,
633            id = id
634        );
635        let mut local_var_req_builder =
636            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
637
638        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
639            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
640        };
641        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
642        local_var_req_builder = local_var_req_builder.json(&provider_user_update_request_model);
643
644        let local_var_req = local_var_req_builder.build()?;
645        let local_var_resp = local_var_client.execute(local_var_req).await?;
646
647        let local_var_status = local_var_resp.status();
648        let local_var_content = local_var_resp.text().await?;
649
650        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
651            Ok(())
652        } else {
653            let local_var_entity: Option<PutError> = serde_json::from_str(&local_var_content).ok();
654            let local_var_error = ResponseContent {
655                status: local_var_status,
656                content: local_var_content,
657                entity: local_var_entity,
658            };
659            Err(Error::ResponseError(local_var_error))
660        }
661    }
662
663    async fn reinvite<'a>(
664        &self,
665        provider_id: uuid::Uuid,
666        id: uuid::Uuid,
667    ) -> Result<(), Error<ReinviteError>> {
668        let local_var_configuration = &self.configuration;
669
670        let local_var_client = &local_var_configuration.client;
671
672        let local_var_uri_str = format!(
673            "{}/providers/{providerId}/users/{id}/reinvite",
674            local_var_configuration.base_path,
675            providerId = provider_id,
676            id = id
677        );
678        let mut local_var_req_builder =
679            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
680
681        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
682            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
683        };
684        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
685
686        let local_var_req = local_var_req_builder.build()?;
687        let local_var_resp = local_var_client.execute(local_var_req).await?;
688
689        let local_var_status = local_var_resp.status();
690        let local_var_content = local_var_resp.text().await?;
691
692        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
693            Ok(())
694        } else {
695            let local_var_entity: Option<ReinviteError> =
696                serde_json::from_str(&local_var_content).ok();
697            let local_var_error = ResponseContent {
698                status: local_var_status,
699                content: local_var_content,
700                entity: local_var_entity,
701            };
702            Err(Error::ResponseError(local_var_error))
703        }
704    }
705
706    async fn user_public_keys<'a>(
707        &self,
708        provider_id: uuid::Uuid,
709        provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
710    ) -> Result<
711        models::ProviderUserPublicKeyResponseModelListResponseModel,
712        Error<UserPublicKeysError>,
713    > {
714        let local_var_configuration = &self.configuration;
715
716        let local_var_client = &local_var_configuration.client;
717
718        let local_var_uri_str = format!(
719            "{}/providers/{providerId}/users/public-keys",
720            local_var_configuration.base_path,
721            providerId = provider_id
722        );
723        let mut local_var_req_builder =
724            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
725
726        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
727            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
728        };
729        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
730        local_var_req_builder = local_var_req_builder.json(&provider_user_bulk_request_model);
731
732        let local_var_req = local_var_req_builder.build()?;
733        let local_var_resp = local_var_client.execute(local_var_req).await?;
734
735        let local_var_status = local_var_resp.status();
736        let local_var_content_type = local_var_resp
737            .headers()
738            .get("content-type")
739            .and_then(|v| v.to_str().ok())
740            .unwrap_or("application/octet-stream");
741        let local_var_content_type = super::ContentType::from(local_var_content_type);
742        let local_var_content = local_var_resp.text().await?;
743
744        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
745            match local_var_content_type {
746                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
747                ContentType::Text => {
748                    return Err(Error::from(serde_json::Error::custom(
749                        "Received `text/plain` content type response that cannot be converted to `models::ProviderUserPublicKeyResponseModelListResponseModel`",
750                    )));
751                }
752                ContentType::Unsupported(local_var_unknown_type) => {
753                    return Err(Error::from(serde_json::Error::custom(format!(
754                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderUserPublicKeyResponseModelListResponseModel`"
755                    ))));
756                }
757            }
758        } else {
759            let local_var_entity: Option<UserPublicKeysError> =
760                serde_json::from_str(&local_var_content).ok();
761            let local_var_error = ResponseContent {
762                status: local_var_status,
763                content: local_var_content,
764                entity: local_var_entity,
765            };
766            Err(Error::ResponseError(local_var_error))
767        }
768    }
769}
770
771/// struct for typed errors of method [`ProviderUsersApi::accept`]
772#[derive(Debug, Clone, Serialize, Deserialize)]
773#[serde(untagged)]
774pub enum AcceptError {
775    UnknownValue(serde_json::Value),
776}
777/// struct for typed errors of method [`ProviderUsersApi::bulk_confirm`]
778#[derive(Debug, Clone, Serialize, Deserialize)]
779#[serde(untagged)]
780pub enum BulkConfirmError {
781    UnknownValue(serde_json::Value),
782}
783/// struct for typed errors of method [`ProviderUsersApi::bulk_delete`]
784#[derive(Debug, Clone, Serialize, Deserialize)]
785#[serde(untagged)]
786pub enum BulkDeleteError {
787    UnknownValue(serde_json::Value),
788}
789/// struct for typed errors of method [`ProviderUsersApi::bulk_reinvite`]
790#[derive(Debug, Clone, Serialize, Deserialize)]
791#[serde(untagged)]
792pub enum BulkReinviteError {
793    UnknownValue(serde_json::Value),
794}
795/// struct for typed errors of method [`ProviderUsersApi::confirm`]
796#[derive(Debug, Clone, Serialize, Deserialize)]
797#[serde(untagged)]
798pub enum ConfirmError {
799    UnknownValue(serde_json::Value),
800}
801/// struct for typed errors of method [`ProviderUsersApi::delete`]
802#[derive(Debug, Clone, Serialize, Deserialize)]
803#[serde(untagged)]
804pub enum DeleteError {
805    UnknownValue(serde_json::Value),
806}
807/// struct for typed errors of method [`ProviderUsersApi::get`]
808#[derive(Debug, Clone, Serialize, Deserialize)]
809#[serde(untagged)]
810pub enum GetError {
811    UnknownValue(serde_json::Value),
812}
813/// struct for typed errors of method [`ProviderUsersApi::get_all`]
814#[derive(Debug, Clone, Serialize, Deserialize)]
815#[serde(untagged)]
816pub enum GetAllError {
817    UnknownValue(serde_json::Value),
818}
819/// struct for typed errors of method [`ProviderUsersApi::invite`]
820#[derive(Debug, Clone, Serialize, Deserialize)]
821#[serde(untagged)]
822pub enum InviteError {
823    UnknownValue(serde_json::Value),
824}
825/// struct for typed errors of method [`ProviderUsersApi::put`]
826#[derive(Debug, Clone, Serialize, Deserialize)]
827#[serde(untagged)]
828pub enum PutError {
829    UnknownValue(serde_json::Value),
830}
831/// struct for typed errors of method [`ProviderUsersApi::reinvite`]
832#[derive(Debug, Clone, Serialize, Deserialize)]
833#[serde(untagged)]
834pub enum ReinviteError {
835    UnknownValue(serde_json::Value),
836}
837/// struct for typed errors of method [`ProviderUsersApi::user_public_keys`]
838#[derive(Debug, Clone, Serialize, Deserialize)]
839#[serde(untagged)]
840pub enum UserPublicKeysError {
841    UnknownValue(serde_json::Value),
842}
bitwarden_api_api/apis/provider_users_api.rs

bitwarden_api_api/apis/
provider_users_api.rs
