bitwarden_api_api/apis/
organization_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 OrganizationUsersApi: Send + Sync {
29    /// POST /organizations/{orgId}/users/{organizationUserId}/accept
30    async fn accept<'a>(
31        &self,
32        org_id: uuid::Uuid,
33        organization_user_id: uuid::Uuid,
34        organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
35    ) -> Result<(), Error<AcceptError>>;
36
37    /// POST /organizations/{orgId}/users/{organizationUserId}/accept-init
38    async fn accept_init<'a>(
39        &self,
40        org_id: uuid::Uuid,
41        organization_user_id: uuid::Uuid,
42        organization_user_accept_init_request_model: Option<
43            models::OrganizationUserAcceptInitRequestModel,
44        >,
45    ) -> Result<(), Error<AcceptInitError>>;
46
47    /// POST /organizations/{orgId}/users/{id}/auto-confirm
48    async fn automatically_confirm_organization_user<'a>(
49        &self,
50        org_id: uuid::Uuid,
51        id: uuid::Uuid,
52        organization_user_confirm_request_model: Option<
53            models::OrganizationUserConfirmRequestModel,
54        >,
55    ) -> Result<(), Error<AutomaticallyConfirmOrganizationUserError>>;
56
57    /// POST /organizations/{orgId}/users/confirm
58    async fn bulk_confirm<'a>(
59        &self,
60        org_id: uuid::Uuid,
61        organization_user_bulk_confirm_request_model: Option<
62            models::OrganizationUserBulkConfirmRequestModel,
63        >,
64    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkConfirmError>>;
65
66    /// DELETE /organizations/{orgId}/users/delete-account
67    async fn bulk_delete_account<'a>(
68        &self,
69        org_id: uuid::Uuid,
70        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
71    ) -> Result<
72        models::OrganizationUserBulkResponseModelListResponseModel,
73        Error<BulkDeleteAccountError>,
74    >;
75
76    /// PUT /organizations/{orgId}/users/enable-secrets-manager
77    async fn bulk_enable_secrets_manager<'a>(
78        &self,
79        org_id: uuid::Uuid,
80        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
81    ) -> Result<(), Error<BulkEnableSecretsManagerError>>;
82
83    /// POST /organizations/{orgId}/users/reinvite
84    async fn bulk_reinvite<'a>(
85        &self,
86        org_id: uuid::Uuid,
87        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
88    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkReinviteError>>;
89
90    /// DELETE /organizations/{orgId}/users
91    async fn bulk_remove<'a>(
92        &self,
93        org_id: uuid::Uuid,
94        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
95    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRemoveError>>;
96
97    /// PUT /organizations/{orgId}/users/restore
98    async fn bulk_restore<'a>(
99        &self,
100        org_id: uuid::Uuid,
101        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
102    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRestoreError>>;
103
104    /// PUT /organizations/{orgId}/users/revoke
105    async fn bulk_revoke<'a>(
106        &self,
107        org_id: uuid::Uuid,
108        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
109    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRevokeError>>;
110
111    /// POST /organizations/{orgId}/users/{id}/confirm
112    async fn confirm<'a>(
113        &self,
114        org_id: uuid::Uuid,
115        id: uuid::Uuid,
116        organization_user_confirm_request_model: Option<
117            models::OrganizationUserConfirmRequestModel,
118        >,
119    ) -> Result<(), Error<ConfirmError>>;
120
121    /// DELETE /organizations/{orgId}/users/{id}/delete-account
122    async fn delete_account<'a>(
123        &self,
124        org_id: uuid::Uuid,
125        id: uuid::Uuid,
126    ) -> Result<(), Error<DeleteAccountError>>;
127
128    /// GET /organizations/{orgId}/users/{id}
129    async fn get<'a>(
130        &self,
131        org_id: uuid::Uuid,
132        id: uuid::Uuid,
133        include_groups: Option<bool>,
134    ) -> Result<models::OrganizationUserDetailsResponseModel, Error<GetError>>;
135
136    /// POST /organizations/{orgId}/users/account-recovery-details
137    async fn get_account_recovery_details<'a>(
138        &self,
139        org_id: uuid::Uuid,
140        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
141    ) -> Result<
142        models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel,
143        Error<GetAccountRecoveryDetailsError>,
144    >;
145
146    /// GET /organizations/{orgId}/users
147    async fn get_all<'a>(
148        &self,
149        org_id: uuid::Uuid,
150        include_groups: Option<bool>,
151        include_collections: Option<bool>,
152    ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error<GetAllError>>;
153
154    /// GET /organizations/{orgId}/users/mini-details
155    async fn get_mini_details<'a>(
156        &self,
157        org_id: uuid::Uuid,
158    ) -> Result<
159        models::OrganizationUserUserMiniDetailsResponseModelListResponseModel,
160        Error<GetMiniDetailsError>,
161    >;
162
163    /// GET /organizations/{orgId}/users/{id}/reset-password-details
164    async fn get_reset_password_details<'a>(
165        &self,
166        org_id: uuid::Uuid,
167        id: uuid::Uuid,
168    ) -> Result<
169        models::OrganizationUserResetPasswordDetailsResponseModel,
170        Error<GetResetPasswordDetailsError>,
171    >;
172
173    /// POST /organizations/{orgId}/users/invite
174    async fn invite<'a>(
175        &self,
176        org_id: uuid::Uuid,
177        organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
178    ) -> Result<(), Error<InviteError>>;
179
180    /// PUT /organizations/{orgId}/users/{id}
181    async fn put<'a>(
182        &self,
183        org_id: uuid::Uuid,
184        id: uuid::Uuid,
185        organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
186    ) -> Result<(), Error<PutError>>;
187
188    /// PUT /organizations/{orgId}/users/{id}/reset-password
189    async fn put_reset_password<'a>(
190        &self,
191        org_id: uuid::Uuid,
192        id: uuid::Uuid,
193        organization_user_reset_password_request_model: Option<
194            models::OrganizationUserResetPasswordRequestModel,
195        >,
196    ) -> Result<(), Error<PutResetPasswordError>>;
197
198    /// PUT /organizations/{orgId}/users/{userId}/reset-password-enrollment
199    async fn put_reset_password_enrollment<'a>(
200        &self,
201        org_id: uuid::Uuid,
202        user_id: uuid::Uuid,
203        organization_user_reset_password_enrollment_request_model: Option<
204            models::OrganizationUserResetPasswordEnrollmentRequestModel,
205        >,
206    ) -> Result<(), Error<PutResetPasswordEnrollmentError>>;
207
208    /// POST /organizations/{orgId}/users/{id}/reinvite
209    async fn reinvite<'a>(
210        &self,
211        org_id: uuid::Uuid,
212        id: uuid::Uuid,
213    ) -> Result<(), Error<ReinviteError>>;
214
215    /// DELETE /organizations/{orgId}/users/{id}
216    async fn remove<'a>(
217        &self,
218        org_id: uuid::Uuid,
219        id: uuid::Uuid,
220    ) -> Result<(), Error<RemoveError>>;
221
222    /// PUT /organizations/{orgId}/users/{id}/restore
223    async fn restore<'a>(
224        &self,
225        org_id: uuid::Uuid,
226        id: uuid::Uuid,
227    ) -> Result<(), Error<RestoreError>>;
228
229    /// PUT /organizations/{orgId}/users/{id}/restore/vnext
230    async fn restore_async_v_next<'a>(
231        &self,
232        org_id: uuid::Uuid,
233        id: uuid::Uuid,
234        organization_user_restore_request: Option<models::OrganizationUserRestoreRequest>,
235    ) -> Result<(), Error<RestoreAsync_vNextError>>;
236
237    /// PUT /organizations/{orgId}/users/{id}/revoke
238    async fn revoke<'a>(
239        &self,
240        org_id: uuid::Uuid,
241        id: uuid::Uuid,
242    ) -> Result<(), Error<RevokeError>>;
243
244    /// PUT /organizations/{orgId}/users/revoke-self
245    async fn revoke_self<'a>(&self, org_id: uuid::Uuid) -> Result<(), Error<RevokeSelfError>>;
246
247    /// POST /organizations/{orgId}/users/public-keys
248    async fn user_public_keys<'a>(
249        &self,
250        org_id: uuid::Uuid,
251        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
252    ) -> Result<
253        models::OrganizationUserPublicKeyResponseModelListResponseModel,
254        Error<UserPublicKeysError>,
255    >;
256}
257
258pub struct OrganizationUsersApiClient {
259    configuration: Arc<configuration::Configuration>,
260}
261
262impl OrganizationUsersApiClient {
263    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
264        Self { configuration }
265    }
266}
267
268#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
269#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
270impl OrganizationUsersApi for OrganizationUsersApiClient {
271    async fn accept<'a>(
272        &self,
273        org_id: uuid::Uuid,
274        organization_user_id: uuid::Uuid,
275        organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
276    ) -> Result<(), Error<AcceptError>> {
277        let local_var_configuration = &self.configuration;
278
279        let local_var_client = &local_var_configuration.client;
280
281        let local_var_uri_str = format!(
282            "{}/organizations/{orgId}/users/{organizationUserId}/accept",
283            local_var_configuration.base_path,
284            orgId = org_id,
285            organizationUserId = organization_user_id
286        );
287        let mut local_var_req_builder =
288            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
289
290        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
291        local_var_req_builder = local_var_req_builder.json(&organization_user_accept_request_model);
292
293        let local_var_resp = local_var_req_builder.send().await?;
294
295        let local_var_status = local_var_resp.status();
296        let local_var_content = local_var_resp.text().await?;
297
298        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
299            Ok(())
300        } else {
301            let local_var_entity: Option<AcceptError> =
302                serde_json::from_str(&local_var_content).ok();
303            let local_var_error = ResponseContent {
304                status: local_var_status,
305                content: local_var_content,
306                entity: local_var_entity,
307            };
308            Err(Error::ResponseError(local_var_error))
309        }
310    }
311
312    async fn accept_init<'a>(
313        &self,
314        org_id: uuid::Uuid,
315        organization_user_id: uuid::Uuid,
316        organization_user_accept_init_request_model: Option<
317            models::OrganizationUserAcceptInitRequestModel,
318        >,
319    ) -> Result<(), Error<AcceptInitError>> {
320        let local_var_configuration = &self.configuration;
321
322        let local_var_client = &local_var_configuration.client;
323
324        let local_var_uri_str = format!(
325            "{}/organizations/{orgId}/users/{organizationUserId}/accept-init",
326            local_var_configuration.base_path,
327            orgId = org_id,
328            organizationUserId = organization_user_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        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
334        local_var_req_builder =
335            local_var_req_builder.json(&organization_user_accept_init_request_model);
336
337        let local_var_resp = local_var_req_builder.send().await?;
338
339        let local_var_status = local_var_resp.status();
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            Ok(())
344        } else {
345            let local_var_entity: Option<AcceptInitError> =
346                serde_json::from_str(&local_var_content).ok();
347            let local_var_error = ResponseContent {
348                status: local_var_status,
349                content: local_var_content,
350                entity: local_var_entity,
351            };
352            Err(Error::ResponseError(local_var_error))
353        }
354    }
355
356    async fn automatically_confirm_organization_user<'a>(
357        &self,
358        org_id: uuid::Uuid,
359        id: uuid::Uuid,
360        organization_user_confirm_request_model: Option<
361            models::OrganizationUserConfirmRequestModel,
362        >,
363    ) -> Result<(), Error<AutomaticallyConfirmOrganizationUserError>> {
364        let local_var_configuration = &self.configuration;
365
366        let local_var_client = &local_var_configuration.client;
367
368        let local_var_uri_str = format!(
369            "{}/organizations/{orgId}/users/{id}/auto-confirm",
370            local_var_configuration.base_path,
371            orgId = org_id,
372            id = id
373        );
374        let mut local_var_req_builder =
375            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
376
377        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
378        local_var_req_builder =
379            local_var_req_builder.json(&organization_user_confirm_request_model);
380
381        let local_var_resp = local_var_req_builder.send().await?;
382
383        let local_var_status = local_var_resp.status();
384        let local_var_content = local_var_resp.text().await?;
385
386        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
387            Ok(())
388        } else {
389            let local_var_entity: Option<AutomaticallyConfirmOrganizationUserError> =
390                serde_json::from_str(&local_var_content).ok();
391            let local_var_error = ResponseContent {
392                status: local_var_status,
393                content: local_var_content,
394                entity: local_var_entity,
395            };
396            Err(Error::ResponseError(local_var_error))
397        }
398    }
399
400    async fn bulk_confirm<'a>(
401        &self,
402        org_id: uuid::Uuid,
403        organization_user_bulk_confirm_request_model: Option<
404            models::OrganizationUserBulkConfirmRequestModel,
405        >,
406    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkConfirmError>>
407    {
408        let local_var_configuration = &self.configuration;
409
410        let local_var_client = &local_var_configuration.client;
411
412        let local_var_uri_str = format!(
413            "{}/organizations/{orgId}/users/confirm",
414            local_var_configuration.base_path,
415            orgId = org_id
416        );
417        let mut local_var_req_builder =
418            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
419
420        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
421        local_var_req_builder =
422            local_var_req_builder.json(&organization_user_bulk_confirm_request_model);
423
424        let local_var_resp = local_var_req_builder.send().await?;
425
426        let local_var_status = local_var_resp.status();
427        let local_var_content_type = local_var_resp
428            .headers()
429            .get("content-type")
430            .and_then(|v| v.to_str().ok())
431            .unwrap_or("application/octet-stream");
432        let local_var_content_type = super::ContentType::from(local_var_content_type);
433        let local_var_content = local_var_resp.text().await?;
434
435        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
436            match local_var_content_type {
437                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
438                ContentType::Text => {
439                    return Err(Error::from(serde_json::Error::custom(
440                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`",
441                    )));
442                }
443                ContentType::Unsupported(local_var_unknown_type) => {
444                    return Err(Error::from(serde_json::Error::custom(format!(
445                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`"
446                    ))));
447                }
448            }
449        } else {
450            let local_var_entity: Option<BulkConfirmError> =
451                serde_json::from_str(&local_var_content).ok();
452            let local_var_error = ResponseContent {
453                status: local_var_status,
454                content: local_var_content,
455                entity: local_var_entity,
456            };
457            Err(Error::ResponseError(local_var_error))
458        }
459    }
460
461    async fn bulk_delete_account<'a>(
462        &self,
463        org_id: uuid::Uuid,
464        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
465    ) -> Result<
466        models::OrganizationUserBulkResponseModelListResponseModel,
467        Error<BulkDeleteAccountError>,
468    > {
469        let local_var_configuration = &self.configuration;
470
471        let local_var_client = &local_var_configuration.client;
472
473        let local_var_uri_str = format!(
474            "{}/organizations/{orgId}/users/delete-account",
475            local_var_configuration.base_path,
476            orgId = org_id
477        );
478        let mut local_var_req_builder =
479            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
480
481        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
482        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
483
484        let local_var_resp = local_var_req_builder.send().await?;
485
486        let local_var_status = local_var_resp.status();
487        let local_var_content_type = local_var_resp
488            .headers()
489            .get("content-type")
490            .and_then(|v| v.to_str().ok())
491            .unwrap_or("application/octet-stream");
492        let local_var_content_type = super::ContentType::from(local_var_content_type);
493        let local_var_content = local_var_resp.text().await?;
494
495        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
496            match local_var_content_type {
497                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
498                ContentType::Text => {
499                    return Err(Error::from(serde_json::Error::custom(
500                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`",
501                    )));
502                }
503                ContentType::Unsupported(local_var_unknown_type) => {
504                    return Err(Error::from(serde_json::Error::custom(format!(
505                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`"
506                    ))));
507                }
508            }
509        } else {
510            let local_var_entity: Option<BulkDeleteAccountError> =
511                serde_json::from_str(&local_var_content).ok();
512            let local_var_error = ResponseContent {
513                status: local_var_status,
514                content: local_var_content,
515                entity: local_var_entity,
516            };
517            Err(Error::ResponseError(local_var_error))
518        }
519    }
520
521    async fn bulk_enable_secrets_manager<'a>(
522        &self,
523        org_id: uuid::Uuid,
524        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
525    ) -> Result<(), Error<BulkEnableSecretsManagerError>> {
526        let local_var_configuration = &self.configuration;
527
528        let local_var_client = &local_var_configuration.client;
529
530        let local_var_uri_str = format!(
531            "{}/organizations/{orgId}/users/enable-secrets-manager",
532            local_var_configuration.base_path,
533            orgId = org_id
534        );
535        let mut local_var_req_builder =
536            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
537
538        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
539        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
540
541        let local_var_resp = local_var_req_builder.send().await?;
542
543        let local_var_status = local_var_resp.status();
544        let local_var_content = local_var_resp.text().await?;
545
546        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
547            Ok(())
548        } else {
549            let local_var_entity: Option<BulkEnableSecretsManagerError> =
550                serde_json::from_str(&local_var_content).ok();
551            let local_var_error = ResponseContent {
552                status: local_var_status,
553                content: local_var_content,
554                entity: local_var_entity,
555            };
556            Err(Error::ResponseError(local_var_error))
557        }
558    }
559
560    async fn bulk_reinvite<'a>(
561        &self,
562        org_id: uuid::Uuid,
563        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
564    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkReinviteError>>
565    {
566        let local_var_configuration = &self.configuration;
567
568        let local_var_client = &local_var_configuration.client;
569
570        let local_var_uri_str = format!(
571            "{}/organizations/{orgId}/users/reinvite",
572            local_var_configuration.base_path,
573            orgId = org_id
574        );
575        let mut local_var_req_builder =
576            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
577
578        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
579        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
580
581        let local_var_resp = local_var_req_builder.send().await?;
582
583        let local_var_status = local_var_resp.status();
584        let local_var_content_type = local_var_resp
585            .headers()
586            .get("content-type")
587            .and_then(|v| v.to_str().ok())
588            .unwrap_or("application/octet-stream");
589        let local_var_content_type = super::ContentType::from(local_var_content_type);
590        let local_var_content = local_var_resp.text().await?;
591
592        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
593            match local_var_content_type {
594                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
595                ContentType::Text => {
596                    return Err(Error::from(serde_json::Error::custom(
597                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`",
598                    )));
599                }
600                ContentType::Unsupported(local_var_unknown_type) => {
601                    return Err(Error::from(serde_json::Error::custom(format!(
602                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`"
603                    ))));
604                }
605            }
606        } else {
607            let local_var_entity: Option<BulkReinviteError> =
608                serde_json::from_str(&local_var_content).ok();
609            let local_var_error = ResponseContent {
610                status: local_var_status,
611                content: local_var_content,
612                entity: local_var_entity,
613            };
614            Err(Error::ResponseError(local_var_error))
615        }
616    }
617
618    async fn bulk_remove<'a>(
619        &self,
620        org_id: uuid::Uuid,
621        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
622    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRemoveError>>
623    {
624        let local_var_configuration = &self.configuration;
625
626        let local_var_client = &local_var_configuration.client;
627
628        let local_var_uri_str = format!(
629            "{}/organizations/{orgId}/users",
630            local_var_configuration.base_path,
631            orgId = org_id
632        );
633        let mut local_var_req_builder =
634            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
635
636        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
637        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
638
639        let local_var_resp = local_var_req_builder.send().await?;
640
641        let local_var_status = local_var_resp.status();
642        let local_var_content_type = local_var_resp
643            .headers()
644            .get("content-type")
645            .and_then(|v| v.to_str().ok())
646            .unwrap_or("application/octet-stream");
647        let local_var_content_type = super::ContentType::from(local_var_content_type);
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            match local_var_content_type {
652                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
653                ContentType::Text => {
654                    return Err(Error::from(serde_json::Error::custom(
655                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`",
656                    )));
657                }
658                ContentType::Unsupported(local_var_unknown_type) => {
659                    return Err(Error::from(serde_json::Error::custom(format!(
660                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`"
661                    ))));
662                }
663            }
664        } else {
665            let local_var_entity: Option<BulkRemoveError> =
666                serde_json::from_str(&local_var_content).ok();
667            let local_var_error = ResponseContent {
668                status: local_var_status,
669                content: local_var_content,
670                entity: local_var_entity,
671            };
672            Err(Error::ResponseError(local_var_error))
673        }
674    }
675
676    async fn bulk_restore<'a>(
677        &self,
678        org_id: uuid::Uuid,
679        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
680    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRestoreError>>
681    {
682        let local_var_configuration = &self.configuration;
683
684        let local_var_client = &local_var_configuration.client;
685
686        let local_var_uri_str = format!(
687            "{}/organizations/{orgId}/users/restore",
688            local_var_configuration.base_path,
689            orgId = org_id
690        );
691        let mut local_var_req_builder =
692            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
693
694        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
695        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
696
697        let local_var_resp = local_var_req_builder.send().await?;
698
699        let local_var_status = local_var_resp.status();
700        let local_var_content_type = local_var_resp
701            .headers()
702            .get("content-type")
703            .and_then(|v| v.to_str().ok())
704            .unwrap_or("application/octet-stream");
705        let local_var_content_type = super::ContentType::from(local_var_content_type);
706        let local_var_content = local_var_resp.text().await?;
707
708        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
709            match local_var_content_type {
710                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
711                ContentType::Text => {
712                    return Err(Error::from(serde_json::Error::custom(
713                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`",
714                    )));
715                }
716                ContentType::Unsupported(local_var_unknown_type) => {
717                    return Err(Error::from(serde_json::Error::custom(format!(
718                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`"
719                    ))));
720                }
721            }
722        } else {
723            let local_var_entity: Option<BulkRestoreError> =
724                serde_json::from_str(&local_var_content).ok();
725            let local_var_error = ResponseContent {
726                status: local_var_status,
727                content: local_var_content,
728                entity: local_var_entity,
729            };
730            Err(Error::ResponseError(local_var_error))
731        }
732    }
733
734    async fn bulk_revoke<'a>(
735        &self,
736        org_id: uuid::Uuid,
737        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
738    ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error<BulkRevokeError>>
739    {
740        let local_var_configuration = &self.configuration;
741
742        let local_var_client = &local_var_configuration.client;
743
744        let local_var_uri_str = format!(
745            "{}/organizations/{orgId}/users/revoke",
746            local_var_configuration.base_path,
747            orgId = org_id
748        );
749        let mut local_var_req_builder =
750            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
751
752        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
753        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
754
755        let local_var_resp = local_var_req_builder.send().await?;
756
757        let local_var_status = local_var_resp.status();
758        let local_var_content_type = local_var_resp
759            .headers()
760            .get("content-type")
761            .and_then(|v| v.to_str().ok())
762            .unwrap_or("application/octet-stream");
763        let local_var_content_type = super::ContentType::from(local_var_content_type);
764        let local_var_content = local_var_resp.text().await?;
765
766        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
767            match local_var_content_type {
768                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
769                ContentType::Text => {
770                    return Err(Error::from(serde_json::Error::custom(
771                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`",
772                    )));
773                }
774                ContentType::Unsupported(local_var_unknown_type) => {
775                    return Err(Error::from(serde_json::Error::custom(format!(
776                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserBulkResponseModelListResponseModel`"
777                    ))));
778                }
779            }
780        } else {
781            let local_var_entity: Option<BulkRevokeError> =
782                serde_json::from_str(&local_var_content).ok();
783            let local_var_error = ResponseContent {
784                status: local_var_status,
785                content: local_var_content,
786                entity: local_var_entity,
787            };
788            Err(Error::ResponseError(local_var_error))
789        }
790    }
791
792    async fn confirm<'a>(
793        &self,
794        org_id: uuid::Uuid,
795        id: uuid::Uuid,
796        organization_user_confirm_request_model: Option<
797            models::OrganizationUserConfirmRequestModel,
798        >,
799    ) -> Result<(), Error<ConfirmError>> {
800        let local_var_configuration = &self.configuration;
801
802        let local_var_client = &local_var_configuration.client;
803
804        let local_var_uri_str = format!(
805            "{}/organizations/{orgId}/users/{id}/confirm",
806            local_var_configuration.base_path,
807            orgId = org_id,
808            id = id
809        );
810        let mut local_var_req_builder =
811            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
812
813        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
814        local_var_req_builder =
815            local_var_req_builder.json(&organization_user_confirm_request_model);
816
817        let local_var_resp = local_var_req_builder.send().await?;
818
819        let local_var_status = local_var_resp.status();
820        let local_var_content = local_var_resp.text().await?;
821
822        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
823            Ok(())
824        } else {
825            let local_var_entity: Option<ConfirmError> =
826                serde_json::from_str(&local_var_content).ok();
827            let local_var_error = ResponseContent {
828                status: local_var_status,
829                content: local_var_content,
830                entity: local_var_entity,
831            };
832            Err(Error::ResponseError(local_var_error))
833        }
834    }
835
836    async fn delete_account<'a>(
837        &self,
838        org_id: uuid::Uuid,
839        id: uuid::Uuid,
840    ) -> Result<(), Error<DeleteAccountError>> {
841        let local_var_configuration = &self.configuration;
842
843        let local_var_client = &local_var_configuration.client;
844
845        let local_var_uri_str = format!(
846            "{}/organizations/{orgId}/users/{id}/delete-account",
847            local_var_configuration.base_path,
848            orgId = org_id,
849            id = id
850        );
851        let mut local_var_req_builder =
852            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
853
854        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
855
856        let local_var_resp = local_var_req_builder.send().await?;
857
858        let local_var_status = local_var_resp.status();
859        let local_var_content = local_var_resp.text().await?;
860
861        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
862            Ok(())
863        } else {
864            let local_var_entity: Option<DeleteAccountError> =
865                serde_json::from_str(&local_var_content).ok();
866            let local_var_error = ResponseContent {
867                status: local_var_status,
868                content: local_var_content,
869                entity: local_var_entity,
870            };
871            Err(Error::ResponseError(local_var_error))
872        }
873    }
874
875    async fn get<'a>(
876        &self,
877        org_id: uuid::Uuid,
878        id: uuid::Uuid,
879        include_groups: Option<bool>,
880    ) -> Result<models::OrganizationUserDetailsResponseModel, Error<GetError>> {
881        let local_var_configuration = &self.configuration;
882
883        let local_var_client = &local_var_configuration.client;
884
885        let local_var_uri_str = format!(
886            "{}/organizations/{orgId}/users/{id}",
887            local_var_configuration.base_path,
888            orgId = org_id,
889            id = id
890        );
891        let mut local_var_req_builder =
892            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
893
894        if let Some(ref param_value) = include_groups {
895            local_var_req_builder =
896                local_var_req_builder.query(&[("includeGroups", &param_value.to_string())]);
897        }
898        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
899
900        let local_var_resp = local_var_req_builder.send().await?;
901
902        let local_var_status = local_var_resp.status();
903        let local_var_content_type = local_var_resp
904            .headers()
905            .get("content-type")
906            .and_then(|v| v.to_str().ok())
907            .unwrap_or("application/octet-stream");
908        let local_var_content_type = super::ContentType::from(local_var_content_type);
909        let local_var_content = local_var_resp.text().await?;
910
911        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
912            match local_var_content_type {
913                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
914                ContentType::Text => {
915                    return Err(Error::from(serde_json::Error::custom(
916                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserDetailsResponseModel`",
917                    )));
918                }
919                ContentType::Unsupported(local_var_unknown_type) => {
920                    return Err(Error::from(serde_json::Error::custom(format!(
921                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserDetailsResponseModel`"
922                    ))));
923                }
924            }
925        } else {
926            let local_var_entity: Option<GetError> = serde_json::from_str(&local_var_content).ok();
927            let local_var_error = ResponseContent {
928                status: local_var_status,
929                content: local_var_content,
930                entity: local_var_entity,
931            };
932            Err(Error::ResponseError(local_var_error))
933        }
934    }
935
936    async fn get_account_recovery_details<'a>(
937        &self,
938        org_id: uuid::Uuid,
939        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
940    ) -> Result<
941        models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel,
942        Error<GetAccountRecoveryDetailsError>,
943    > {
944        let local_var_configuration = &self.configuration;
945
946        let local_var_client = &local_var_configuration.client;
947
948        let local_var_uri_str = format!(
949            "{}/organizations/{orgId}/users/account-recovery-details",
950            local_var_configuration.base_path,
951            orgId = org_id
952        );
953        let mut local_var_req_builder =
954            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
955
956        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
957        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
958
959        let local_var_resp = local_var_req_builder.send().await?;
960
961        let local_var_status = local_var_resp.status();
962        let local_var_content_type = local_var_resp
963            .headers()
964            .get("content-type")
965            .and_then(|v| v.to_str().ok())
966            .unwrap_or("application/octet-stream");
967        let local_var_content_type = super::ContentType::from(local_var_content_type);
968        let local_var_content = local_var_resp.text().await?;
969
970        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
971            match local_var_content_type {
972                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
973                ContentType::Text => {
974                    return Err(Error::from(serde_json::Error::custom(
975                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel`",
976                    )));
977                }
978                ContentType::Unsupported(local_var_unknown_type) => {
979                    return Err(Error::from(serde_json::Error::custom(format!(
980                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel`"
981                    ))));
982                }
983            }
984        } else {
985            let local_var_entity: Option<GetAccountRecoveryDetailsError> =
986                serde_json::from_str(&local_var_content).ok();
987            let local_var_error = ResponseContent {
988                status: local_var_status,
989                content: local_var_content,
990                entity: local_var_entity,
991            };
992            Err(Error::ResponseError(local_var_error))
993        }
994    }
995
996    async fn get_all<'a>(
997        &self,
998        org_id: uuid::Uuid,
999        include_groups: Option<bool>,
1000        include_collections: Option<bool>,
1001    ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error<GetAllError>>
1002    {
1003        let local_var_configuration = &self.configuration;
1004
1005        let local_var_client = &local_var_configuration.client;
1006
1007        let local_var_uri_str = format!(
1008            "{}/organizations/{orgId}/users",
1009            local_var_configuration.base_path,
1010            orgId = org_id
1011        );
1012        let mut local_var_req_builder =
1013            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1014
1015        if let Some(ref param_value) = include_groups {
1016            local_var_req_builder =
1017                local_var_req_builder.query(&[("includeGroups", &param_value.to_string())]);
1018        }
1019        if let Some(ref param_value) = include_collections {
1020            local_var_req_builder =
1021                local_var_req_builder.query(&[("includeCollections", &param_value.to_string())]);
1022        }
1023        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1024
1025        let local_var_resp = local_var_req_builder.send().await?;
1026
1027        let local_var_status = local_var_resp.status();
1028        let local_var_content_type = local_var_resp
1029            .headers()
1030            .get("content-type")
1031            .and_then(|v| v.to_str().ok())
1032            .unwrap_or("application/octet-stream");
1033        let local_var_content_type = super::ContentType::from(local_var_content_type);
1034        let local_var_content = local_var_resp.text().await?;
1035
1036        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1037            match local_var_content_type {
1038                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1039                ContentType::Text => {
1040                    return Err(Error::from(serde_json::Error::custom(
1041                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserUserDetailsResponseModelListResponseModel`",
1042                    )));
1043                }
1044                ContentType::Unsupported(local_var_unknown_type) => {
1045                    return Err(Error::from(serde_json::Error::custom(format!(
1046                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserUserDetailsResponseModelListResponseModel`"
1047                    ))));
1048                }
1049            }
1050        } else {
1051            let local_var_entity: Option<GetAllError> =
1052                serde_json::from_str(&local_var_content).ok();
1053            let local_var_error = ResponseContent {
1054                status: local_var_status,
1055                content: local_var_content,
1056                entity: local_var_entity,
1057            };
1058            Err(Error::ResponseError(local_var_error))
1059        }
1060    }
1061
1062    async fn get_mini_details<'a>(
1063        &self,
1064        org_id: uuid::Uuid,
1065    ) -> Result<
1066        models::OrganizationUserUserMiniDetailsResponseModelListResponseModel,
1067        Error<GetMiniDetailsError>,
1068    > {
1069        let local_var_configuration = &self.configuration;
1070
1071        let local_var_client = &local_var_configuration.client;
1072
1073        let local_var_uri_str = format!(
1074            "{}/organizations/{orgId}/users/mini-details",
1075            local_var_configuration.base_path,
1076            orgId = org_id
1077        );
1078        let mut local_var_req_builder =
1079            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1080
1081        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1082
1083        let local_var_resp = local_var_req_builder.send().await?;
1084
1085        let local_var_status = local_var_resp.status();
1086        let local_var_content_type = local_var_resp
1087            .headers()
1088            .get("content-type")
1089            .and_then(|v| v.to_str().ok())
1090            .unwrap_or("application/octet-stream");
1091        let local_var_content_type = super::ContentType::from(local_var_content_type);
1092        let local_var_content = local_var_resp.text().await?;
1093
1094        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1095            match local_var_content_type {
1096                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1097                ContentType::Text => {
1098                    return Err(Error::from(serde_json::Error::custom(
1099                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserUserMiniDetailsResponseModelListResponseModel`",
1100                    )));
1101                }
1102                ContentType::Unsupported(local_var_unknown_type) => {
1103                    return Err(Error::from(serde_json::Error::custom(format!(
1104                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserUserMiniDetailsResponseModelListResponseModel`"
1105                    ))));
1106                }
1107            }
1108        } else {
1109            let local_var_entity: Option<GetMiniDetailsError> =
1110                serde_json::from_str(&local_var_content).ok();
1111            let local_var_error = ResponseContent {
1112                status: local_var_status,
1113                content: local_var_content,
1114                entity: local_var_entity,
1115            };
1116            Err(Error::ResponseError(local_var_error))
1117        }
1118    }
1119
1120    async fn get_reset_password_details<'a>(
1121        &self,
1122        org_id: uuid::Uuid,
1123        id: uuid::Uuid,
1124    ) -> Result<
1125        models::OrganizationUserResetPasswordDetailsResponseModel,
1126        Error<GetResetPasswordDetailsError>,
1127    > {
1128        let local_var_configuration = &self.configuration;
1129
1130        let local_var_client = &local_var_configuration.client;
1131
1132        let local_var_uri_str = format!(
1133            "{}/organizations/{orgId}/users/{id}/reset-password-details",
1134            local_var_configuration.base_path,
1135            orgId = org_id,
1136            id = id
1137        );
1138        let mut local_var_req_builder =
1139            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1140
1141        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1142
1143        let local_var_resp = local_var_req_builder.send().await?;
1144
1145        let local_var_status = local_var_resp.status();
1146        let local_var_content_type = local_var_resp
1147            .headers()
1148            .get("content-type")
1149            .and_then(|v| v.to_str().ok())
1150            .unwrap_or("application/octet-stream");
1151        let local_var_content_type = super::ContentType::from(local_var_content_type);
1152        let local_var_content = local_var_resp.text().await?;
1153
1154        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1155            match local_var_content_type {
1156                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1157                ContentType::Text => {
1158                    return Err(Error::from(serde_json::Error::custom(
1159                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserResetPasswordDetailsResponseModel`",
1160                    )));
1161                }
1162                ContentType::Unsupported(local_var_unknown_type) => {
1163                    return Err(Error::from(serde_json::Error::custom(format!(
1164                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserResetPasswordDetailsResponseModel`"
1165                    ))));
1166                }
1167            }
1168        } else {
1169            let local_var_entity: Option<GetResetPasswordDetailsError> =
1170                serde_json::from_str(&local_var_content).ok();
1171            let local_var_error = ResponseContent {
1172                status: local_var_status,
1173                content: local_var_content,
1174                entity: local_var_entity,
1175            };
1176            Err(Error::ResponseError(local_var_error))
1177        }
1178    }
1179
1180    async fn invite<'a>(
1181        &self,
1182        org_id: uuid::Uuid,
1183        organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
1184    ) -> Result<(), Error<InviteError>> {
1185        let local_var_configuration = &self.configuration;
1186
1187        let local_var_client = &local_var_configuration.client;
1188
1189        let local_var_uri_str = format!(
1190            "{}/organizations/{orgId}/users/invite",
1191            local_var_configuration.base_path,
1192            orgId = org_id
1193        );
1194        let mut local_var_req_builder =
1195            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1196
1197        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1198        local_var_req_builder = local_var_req_builder.json(&organization_user_invite_request_model);
1199
1200        let local_var_resp = local_var_req_builder.send().await?;
1201
1202        let local_var_status = local_var_resp.status();
1203        let local_var_content = local_var_resp.text().await?;
1204
1205        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1206            Ok(())
1207        } else {
1208            let local_var_entity: Option<InviteError> =
1209                serde_json::from_str(&local_var_content).ok();
1210            let local_var_error = ResponseContent {
1211                status: local_var_status,
1212                content: local_var_content,
1213                entity: local_var_entity,
1214            };
1215            Err(Error::ResponseError(local_var_error))
1216        }
1217    }
1218
1219    async fn put<'a>(
1220        &self,
1221        org_id: uuid::Uuid,
1222        id: uuid::Uuid,
1223        organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
1224    ) -> Result<(), Error<PutError>> {
1225        let local_var_configuration = &self.configuration;
1226
1227        let local_var_client = &local_var_configuration.client;
1228
1229        let local_var_uri_str = format!(
1230            "{}/organizations/{orgId}/users/{id}",
1231            local_var_configuration.base_path,
1232            orgId = org_id,
1233            id = id
1234        );
1235        let mut local_var_req_builder =
1236            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1237
1238        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1239        local_var_req_builder = local_var_req_builder.json(&organization_user_update_request_model);
1240
1241        let local_var_resp = local_var_req_builder.send().await?;
1242
1243        let local_var_status = local_var_resp.status();
1244        let local_var_content = local_var_resp.text().await?;
1245
1246        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1247            Ok(())
1248        } else {
1249            let local_var_entity: Option<PutError> = serde_json::from_str(&local_var_content).ok();
1250            let local_var_error = ResponseContent {
1251                status: local_var_status,
1252                content: local_var_content,
1253                entity: local_var_entity,
1254            };
1255            Err(Error::ResponseError(local_var_error))
1256        }
1257    }
1258
1259    async fn put_reset_password<'a>(
1260        &self,
1261        org_id: uuid::Uuid,
1262        id: uuid::Uuid,
1263        organization_user_reset_password_request_model: Option<
1264            models::OrganizationUserResetPasswordRequestModel,
1265        >,
1266    ) -> Result<(), Error<PutResetPasswordError>> {
1267        let local_var_configuration = &self.configuration;
1268
1269        let local_var_client = &local_var_configuration.client;
1270
1271        let local_var_uri_str = format!(
1272            "{}/organizations/{orgId}/users/{id}/reset-password",
1273            local_var_configuration.base_path,
1274            orgId = org_id,
1275            id = id
1276        );
1277        let mut local_var_req_builder =
1278            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1279
1280        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1281        local_var_req_builder =
1282            local_var_req_builder.json(&organization_user_reset_password_request_model);
1283
1284        let local_var_resp = local_var_req_builder.send().await?;
1285
1286        let local_var_status = local_var_resp.status();
1287        let local_var_content = local_var_resp.text().await?;
1288
1289        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1290            Ok(())
1291        } else {
1292            let local_var_entity: Option<PutResetPasswordError> =
1293                serde_json::from_str(&local_var_content).ok();
1294            let local_var_error = ResponseContent {
1295                status: local_var_status,
1296                content: local_var_content,
1297                entity: local_var_entity,
1298            };
1299            Err(Error::ResponseError(local_var_error))
1300        }
1301    }
1302
1303    async fn put_reset_password_enrollment<'a>(
1304        &self,
1305        org_id: uuid::Uuid,
1306        user_id: uuid::Uuid,
1307        organization_user_reset_password_enrollment_request_model: Option<
1308            models::OrganizationUserResetPasswordEnrollmentRequestModel,
1309        >,
1310    ) -> Result<(), Error<PutResetPasswordEnrollmentError>> {
1311        let local_var_configuration = &self.configuration;
1312
1313        let local_var_client = &local_var_configuration.client;
1314
1315        let local_var_uri_str = format!(
1316            "{}/organizations/{orgId}/users/{userId}/reset-password-enrollment",
1317            local_var_configuration.base_path,
1318            orgId = org_id,
1319            userId = user_id
1320        );
1321        let mut local_var_req_builder =
1322            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1323
1324        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1325        local_var_req_builder =
1326            local_var_req_builder.json(&organization_user_reset_password_enrollment_request_model);
1327
1328        let local_var_resp = local_var_req_builder.send().await?;
1329
1330        let local_var_status = local_var_resp.status();
1331        let local_var_content = local_var_resp.text().await?;
1332
1333        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1334            Ok(())
1335        } else {
1336            let local_var_entity: Option<PutResetPasswordEnrollmentError> =
1337                serde_json::from_str(&local_var_content).ok();
1338            let local_var_error = ResponseContent {
1339                status: local_var_status,
1340                content: local_var_content,
1341                entity: local_var_entity,
1342            };
1343            Err(Error::ResponseError(local_var_error))
1344        }
1345    }
1346
1347    async fn reinvite<'a>(
1348        &self,
1349        org_id: uuid::Uuid,
1350        id: uuid::Uuid,
1351    ) -> Result<(), Error<ReinviteError>> {
1352        let local_var_configuration = &self.configuration;
1353
1354        let local_var_client = &local_var_configuration.client;
1355
1356        let local_var_uri_str = format!(
1357            "{}/organizations/{orgId}/users/{id}/reinvite",
1358            local_var_configuration.base_path,
1359            orgId = org_id,
1360            id = id
1361        );
1362        let mut local_var_req_builder =
1363            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1364
1365        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1366
1367        let local_var_resp = local_var_req_builder.send().await?;
1368
1369        let local_var_status = local_var_resp.status();
1370        let local_var_content = local_var_resp.text().await?;
1371
1372        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1373            Ok(())
1374        } else {
1375            let local_var_entity: Option<ReinviteError> =
1376                serde_json::from_str(&local_var_content).ok();
1377            let local_var_error = ResponseContent {
1378                status: local_var_status,
1379                content: local_var_content,
1380                entity: local_var_entity,
1381            };
1382            Err(Error::ResponseError(local_var_error))
1383        }
1384    }
1385
1386    async fn remove<'a>(
1387        &self,
1388        org_id: uuid::Uuid,
1389        id: uuid::Uuid,
1390    ) -> Result<(), Error<RemoveError>> {
1391        let local_var_configuration = &self.configuration;
1392
1393        let local_var_client = &local_var_configuration.client;
1394
1395        let local_var_uri_str = format!(
1396            "{}/organizations/{orgId}/users/{id}",
1397            local_var_configuration.base_path,
1398            orgId = org_id,
1399            id = id
1400        );
1401        let mut local_var_req_builder =
1402            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1403
1404        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1405
1406        let local_var_resp = local_var_req_builder.send().await?;
1407
1408        let local_var_status = local_var_resp.status();
1409        let local_var_content = local_var_resp.text().await?;
1410
1411        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1412            Ok(())
1413        } else {
1414            let local_var_entity: Option<RemoveError> =
1415                serde_json::from_str(&local_var_content).ok();
1416            let local_var_error = ResponseContent {
1417                status: local_var_status,
1418                content: local_var_content,
1419                entity: local_var_entity,
1420            };
1421            Err(Error::ResponseError(local_var_error))
1422        }
1423    }
1424
1425    async fn restore<'a>(
1426        &self,
1427        org_id: uuid::Uuid,
1428        id: uuid::Uuid,
1429    ) -> Result<(), Error<RestoreError>> {
1430        let local_var_configuration = &self.configuration;
1431
1432        let local_var_client = &local_var_configuration.client;
1433
1434        let local_var_uri_str = format!(
1435            "{}/organizations/{orgId}/users/{id}/restore",
1436            local_var_configuration.base_path,
1437            orgId = org_id,
1438            id = id
1439        );
1440        let mut local_var_req_builder =
1441            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1442
1443        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1444
1445        let local_var_resp = local_var_req_builder.send().await?;
1446
1447        let local_var_status = local_var_resp.status();
1448        let local_var_content = local_var_resp.text().await?;
1449
1450        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1451            Ok(())
1452        } else {
1453            let local_var_entity: Option<RestoreError> =
1454                serde_json::from_str(&local_var_content).ok();
1455            let local_var_error = ResponseContent {
1456                status: local_var_status,
1457                content: local_var_content,
1458                entity: local_var_entity,
1459            };
1460            Err(Error::ResponseError(local_var_error))
1461        }
1462    }
1463
1464    async fn restore_async_v_next<'a>(
1465        &self,
1466        org_id: uuid::Uuid,
1467        id: uuid::Uuid,
1468        organization_user_restore_request: Option<models::OrganizationUserRestoreRequest>,
1469    ) -> Result<(), Error<RestoreAsync_vNextError>> {
1470        let local_var_configuration = &self.configuration;
1471
1472        let local_var_client = &local_var_configuration.client;
1473
1474        let local_var_uri_str = format!(
1475            "{}/organizations/{orgId}/users/{id}/restore/vnext",
1476            local_var_configuration.base_path,
1477            orgId = org_id,
1478            id = id
1479        );
1480        let mut local_var_req_builder =
1481            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1482
1483        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1484        local_var_req_builder = local_var_req_builder.json(&organization_user_restore_request);
1485
1486        let local_var_resp = local_var_req_builder.send().await?;
1487
1488        let local_var_status = local_var_resp.status();
1489        let local_var_content = local_var_resp.text().await?;
1490
1491        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1492            Ok(())
1493        } else {
1494            let local_var_entity: Option<RestoreAsync_vNextError> =
1495                serde_json::from_str(&local_var_content).ok();
1496            let local_var_error = ResponseContent {
1497                status: local_var_status,
1498                content: local_var_content,
1499                entity: local_var_entity,
1500            };
1501            Err(Error::ResponseError(local_var_error))
1502        }
1503    }
1504
1505    async fn revoke<'a>(
1506        &self,
1507        org_id: uuid::Uuid,
1508        id: uuid::Uuid,
1509    ) -> Result<(), Error<RevokeError>> {
1510        let local_var_configuration = &self.configuration;
1511
1512        let local_var_client = &local_var_configuration.client;
1513
1514        let local_var_uri_str = format!(
1515            "{}/organizations/{orgId}/users/{id}/revoke",
1516            local_var_configuration.base_path,
1517            orgId = org_id,
1518            id = id
1519        );
1520        let mut local_var_req_builder =
1521            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1522
1523        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1524
1525        let local_var_resp = local_var_req_builder.send().await?;
1526
1527        let local_var_status = local_var_resp.status();
1528        let local_var_content = local_var_resp.text().await?;
1529
1530        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1531            Ok(())
1532        } else {
1533            let local_var_entity: Option<RevokeError> =
1534                serde_json::from_str(&local_var_content).ok();
1535            let local_var_error = ResponseContent {
1536                status: local_var_status,
1537                content: local_var_content,
1538                entity: local_var_entity,
1539            };
1540            Err(Error::ResponseError(local_var_error))
1541        }
1542    }
1543
1544    async fn revoke_self<'a>(&self, org_id: uuid::Uuid) -> Result<(), Error<RevokeSelfError>> {
1545        let local_var_configuration = &self.configuration;
1546
1547        let local_var_client = &local_var_configuration.client;
1548
1549        let local_var_uri_str = format!(
1550            "{}/organizations/{orgId}/users/revoke-self",
1551            local_var_configuration.base_path,
1552            orgId = org_id
1553        );
1554        let mut local_var_req_builder =
1555            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1556
1557        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1558
1559        let local_var_resp = local_var_req_builder.send().await?;
1560
1561        let local_var_status = local_var_resp.status();
1562        let local_var_content = local_var_resp.text().await?;
1563
1564        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1565            Ok(())
1566        } else {
1567            let local_var_entity: Option<RevokeSelfError> =
1568                serde_json::from_str(&local_var_content).ok();
1569            let local_var_error = ResponseContent {
1570                status: local_var_status,
1571                content: local_var_content,
1572                entity: local_var_entity,
1573            };
1574            Err(Error::ResponseError(local_var_error))
1575        }
1576    }
1577
1578    async fn user_public_keys<'a>(
1579        &self,
1580        org_id: uuid::Uuid,
1581        organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
1582    ) -> Result<
1583        models::OrganizationUserPublicKeyResponseModelListResponseModel,
1584        Error<UserPublicKeysError>,
1585    > {
1586        let local_var_configuration = &self.configuration;
1587
1588        let local_var_client = &local_var_configuration.client;
1589
1590        let local_var_uri_str = format!(
1591            "{}/organizations/{orgId}/users/public-keys",
1592            local_var_configuration.base_path,
1593            orgId = org_id
1594        );
1595        let mut local_var_req_builder =
1596            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1597
1598        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1599        local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
1600
1601        let local_var_resp = local_var_req_builder.send().await?;
1602
1603        let local_var_status = local_var_resp.status();
1604        let local_var_content_type = local_var_resp
1605            .headers()
1606            .get("content-type")
1607            .and_then(|v| v.to_str().ok())
1608            .unwrap_or("application/octet-stream");
1609        let local_var_content_type = super::ContentType::from(local_var_content_type);
1610        let local_var_content = local_var_resp.text().await?;
1611
1612        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1613            match local_var_content_type {
1614                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
1615                ContentType::Text => {
1616                    return Err(Error::from(serde_json::Error::custom(
1617                        "Received `text/plain` content type response that cannot be converted to `models::OrganizationUserPublicKeyResponseModelListResponseModel`",
1618                    )));
1619                }
1620                ContentType::Unsupported(local_var_unknown_type) => {
1621                    return Err(Error::from(serde_json::Error::custom(format!(
1622                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::OrganizationUserPublicKeyResponseModelListResponseModel`"
1623                    ))));
1624                }
1625            }
1626        } else {
1627            let local_var_entity: Option<UserPublicKeysError> =
1628                serde_json::from_str(&local_var_content).ok();
1629            let local_var_error = ResponseContent {
1630                status: local_var_status,
1631                content: local_var_content,
1632                entity: local_var_entity,
1633            };
1634            Err(Error::ResponseError(local_var_error))
1635        }
1636    }
1637}
1638
1639/// struct for typed errors of method [`OrganizationUsersApi::accept`]
1640#[derive(Debug, Clone, Serialize, Deserialize)]
1641#[serde(untagged)]
1642pub enum AcceptError {
1643    UnknownValue(serde_json::Value),
1644}
1645/// struct for typed errors of method [`OrganizationUsersApi::accept_init`]
1646#[derive(Debug, Clone, Serialize, Deserialize)]
1647#[serde(untagged)]
1648pub enum AcceptInitError {
1649    UnknownValue(serde_json::Value),
1650}
1651/// struct for typed errors of method
1652/// [`OrganizationUsersApi::automatically_confirm_organization_user`]
1653#[derive(Debug, Clone, Serialize, Deserialize)]
1654#[serde(untagged)]
1655pub enum AutomaticallyConfirmOrganizationUserError {
1656    UnknownValue(serde_json::Value),
1657}
1658/// struct for typed errors of method [`OrganizationUsersApi::bulk_confirm`]
1659#[derive(Debug, Clone, Serialize, Deserialize)]
1660#[serde(untagged)]
1661pub enum BulkConfirmError {
1662    UnknownValue(serde_json::Value),
1663}
1664/// struct for typed errors of method [`OrganizationUsersApi::bulk_delete_account`]
1665#[derive(Debug, Clone, Serialize, Deserialize)]
1666#[serde(untagged)]
1667pub enum BulkDeleteAccountError {
1668    UnknownValue(serde_json::Value),
1669}
1670/// struct for typed errors of method [`OrganizationUsersApi::bulk_enable_secrets_manager`]
1671#[derive(Debug, Clone, Serialize, Deserialize)]
1672#[serde(untagged)]
1673pub enum BulkEnableSecretsManagerError {
1674    UnknownValue(serde_json::Value),
1675}
1676/// struct for typed errors of method [`OrganizationUsersApi::bulk_reinvite`]
1677#[derive(Debug, Clone, Serialize, Deserialize)]
1678#[serde(untagged)]
1679pub enum BulkReinviteError {
1680    UnknownValue(serde_json::Value),
1681}
1682/// struct for typed errors of method [`OrganizationUsersApi::bulk_remove`]
1683#[derive(Debug, Clone, Serialize, Deserialize)]
1684#[serde(untagged)]
1685pub enum BulkRemoveError {
1686    UnknownValue(serde_json::Value),
1687}
1688/// struct for typed errors of method [`OrganizationUsersApi::bulk_restore`]
1689#[derive(Debug, Clone, Serialize, Deserialize)]
1690#[serde(untagged)]
1691pub enum BulkRestoreError {
1692    UnknownValue(serde_json::Value),
1693}
1694/// struct for typed errors of method [`OrganizationUsersApi::bulk_revoke`]
1695#[derive(Debug, Clone, Serialize, Deserialize)]
1696#[serde(untagged)]
1697pub enum BulkRevokeError {
1698    UnknownValue(serde_json::Value),
1699}
1700/// struct for typed errors of method [`OrganizationUsersApi::confirm`]
1701#[derive(Debug, Clone, Serialize, Deserialize)]
1702#[serde(untagged)]
1703pub enum ConfirmError {
1704    UnknownValue(serde_json::Value),
1705}
1706/// struct for typed errors of method [`OrganizationUsersApi::delete_account`]
1707#[derive(Debug, Clone, Serialize, Deserialize)]
1708#[serde(untagged)]
1709pub enum DeleteAccountError {
1710    UnknownValue(serde_json::Value),
1711}
1712/// struct for typed errors of method [`OrganizationUsersApi::get`]
1713#[derive(Debug, Clone, Serialize, Deserialize)]
1714#[serde(untagged)]
1715pub enum GetError {
1716    UnknownValue(serde_json::Value),
1717}
1718/// struct for typed errors of method [`OrganizationUsersApi::get_account_recovery_details`]
1719#[derive(Debug, Clone, Serialize, Deserialize)]
1720#[serde(untagged)]
1721pub enum GetAccountRecoveryDetailsError {
1722    UnknownValue(serde_json::Value),
1723}
1724/// struct for typed errors of method [`OrganizationUsersApi::get_all`]
1725#[derive(Debug, Clone, Serialize, Deserialize)]
1726#[serde(untagged)]
1727pub enum GetAllError {
1728    UnknownValue(serde_json::Value),
1729}
1730/// struct for typed errors of method [`OrganizationUsersApi::get_mini_details`]
1731#[derive(Debug, Clone, Serialize, Deserialize)]
1732#[serde(untagged)]
1733pub enum GetMiniDetailsError {
1734    UnknownValue(serde_json::Value),
1735}
1736/// struct for typed errors of method [`OrganizationUsersApi::get_reset_password_details`]
1737#[derive(Debug, Clone, Serialize, Deserialize)]
1738#[serde(untagged)]
1739pub enum GetResetPasswordDetailsError {
1740    UnknownValue(serde_json::Value),
1741}
1742/// struct for typed errors of method [`OrganizationUsersApi::invite`]
1743#[derive(Debug, Clone, Serialize, Deserialize)]
1744#[serde(untagged)]
1745pub enum InviteError {
1746    UnknownValue(serde_json::Value),
1747}
1748/// struct for typed errors of method [`OrganizationUsersApi::put`]
1749#[derive(Debug, Clone, Serialize, Deserialize)]
1750#[serde(untagged)]
1751pub enum PutError {
1752    UnknownValue(serde_json::Value),
1753}
1754/// struct for typed errors of method [`OrganizationUsersApi::put_reset_password`]
1755#[derive(Debug, Clone, Serialize, Deserialize)]
1756#[serde(untagged)]
1757pub enum PutResetPasswordError {
1758    UnknownValue(serde_json::Value),
1759}
1760/// struct for typed errors of method [`OrganizationUsersApi::put_reset_password_enrollment`]
1761#[derive(Debug, Clone, Serialize, Deserialize)]
1762#[serde(untagged)]
1763pub enum PutResetPasswordEnrollmentError {
1764    UnknownValue(serde_json::Value),
1765}
1766/// struct for typed errors of method [`OrganizationUsersApi::reinvite`]
1767#[derive(Debug, Clone, Serialize, Deserialize)]
1768#[serde(untagged)]
1769pub enum ReinviteError {
1770    UnknownValue(serde_json::Value),
1771}
1772/// struct for typed errors of method [`OrganizationUsersApi::remove`]
1773#[derive(Debug, Clone, Serialize, Deserialize)]
1774#[serde(untagged)]
1775pub enum RemoveError {
1776    UnknownValue(serde_json::Value),
1777}
1778/// struct for typed errors of method [`OrganizationUsersApi::restore`]
1779#[derive(Debug, Clone, Serialize, Deserialize)]
1780#[serde(untagged)]
1781pub enum RestoreError {
1782    UnknownValue(serde_json::Value),
1783}
1784/// struct for typed errors of method [`OrganizationUsersApi::restore_async_v_next`]
1785#[derive(Debug, Clone, Serialize, Deserialize)]
1786#[serde(untagged)]
1787pub enum RestoreAsync_vNextError {
1788    UnknownValue(serde_json::Value),
1789}
1790/// struct for typed errors of method [`OrganizationUsersApi::revoke`]
1791#[derive(Debug, Clone, Serialize, Deserialize)]
1792#[serde(untagged)]
1793pub enum RevokeError {
1794    UnknownValue(serde_json::Value),
1795}
1796/// struct for typed errors of method [`OrganizationUsersApi::revoke_self`]
1797#[derive(Debug, Clone, Serialize, Deserialize)]
1798#[serde(untagged)]
1799pub enum RevokeSelfError {
1800    UnknownValue(serde_json::Value),
1801}
1802/// struct for typed errors of method [`OrganizationUsersApi::user_public_keys`]
1803#[derive(Debug, Clone, Serialize, Deserialize)]
1804#[serde(untagged)]
1805pub enum UserPublicKeysError {
1806    UnknownValue(serde_json::Value),
1807}
bitwarden_api_api/apis/organization_users_api.rs

bitwarden_api_api/apis/
organization_users_api.rs
