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

bitwarden_api_api/apis/
provider_users_api.rs
