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

bitwarden_api_api/apis/
provider_users_api.rs
