1use 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 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>;
36
37 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>;
46
47 async fn accept_invite_link<'a>(
49 &self,
50 accept_organization_invite_link_request_model: Option<
51 models::AcceptOrganizationInviteLinkRequestModel,
52 >,
53 ) -> Result<(), Error>;
54
55 async fn automatically_confirm_organization_user<'a>(
57 &self,
58 id: uuid::Uuid,
59 org_id: &'a str,
60 organization: Option<models::Organization>,
61 organization_user_confirm_request_model: Option<
62 models::OrganizationUserConfirmRequestModel,
63 >,
64 ) -> Result<(), Error>;
65
66 async fn bulk_automatically_confirm_organization_users<'a>(
68 &self,
69 org_id: &'a str,
70 organization: Option<models::Organization>,
71 organization_user_bulk_confirm_request_model: Option<
72 models::OrganizationUserBulkConfirmRequestModel,
73 >,
74 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
75
76 async fn bulk_confirm<'a>(
78 &self,
79 org_id: uuid::Uuid,
80 organization_user_bulk_confirm_request_model: Option<
81 models::OrganizationUserBulkConfirmRequestModel,
82 >,
83 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
84
85 async fn bulk_delete_account<'a>(
87 &self,
88 org_id: uuid::Uuid,
89 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
90 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
91
92 async fn bulk_enable_pam<'a>(
94 &self,
95 org_id: uuid::Uuid,
96 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
97 ) -> Result<(), Error>;
98
99 async fn bulk_enable_secrets_manager<'a>(
101 &self,
102 org_id: uuid::Uuid,
103 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
104 ) -> Result<(), Error>;
105
106 async fn bulk_reinvite<'a>(
108 &self,
109 org_id: uuid::Uuid,
110 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
111 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
112
113 async fn bulk_remove<'a>(
115 &self,
116 org_id: uuid::Uuid,
117 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
118 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
119
120 async fn bulk_restore<'a>(
122 &self,
123 org_id: uuid::Uuid,
124 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
125 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
126
127 async fn bulk_revoke<'a>(
129 &self,
130 org_id: uuid::Uuid,
131 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
132 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
133
134 async fn confirm<'a>(
136 &self,
137 org_id: uuid::Uuid,
138 id: uuid::Uuid,
139 organization_user_confirm_request_model: Option<
140 models::OrganizationUserConfirmRequestModel,
141 >,
142 ) -> Result<(), Error>;
143
144 async fn confirm_invite_link<'a>(
146 &self,
147 confirm_organization_invite_link_request_model: Option<
148 models::ConfirmOrganizationInviteLinkRequestModel,
149 >,
150 ) -> Result<(), Error>;
151
152 async fn delete_account<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
154
155 async fn get<'a>(
157 &self,
158 org_id: uuid::Uuid,
159 id: uuid::Uuid,
160 include_groups: Option<bool>,
161 ) -> Result<models::OrganizationUserDetailsResponseModel, Error>;
162
163 async fn get_account_recovery_details<'a>(
165 &self,
166 org_id: uuid::Uuid,
167 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
168 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel, Error>;
169
170 async fn get_all<'a>(
172 &self,
173 org_id: uuid::Uuid,
174 include_groups: Option<bool>,
175 include_collections: Option<bool>,
176 ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error>;
177
178 async fn get_invite<'a>(
180 &self,
181 get_organization_invite_request_model: Option<models::GetOrganizationInviteRequestModel>,
182 ) -> Result<models::OrganizationInviteResponseModel, Error>;
183
184 async fn get_mini_details<'a>(
186 &self,
187 org_id: uuid::Uuid,
188 ) -> Result<models::OrganizationUserUserMiniDetailsResponseModelListResponseModel, Error>;
189
190 async fn get_pending_auto_confirm_users<'a>(
192 &self,
193 org_id: uuid::Uuid,
194 ) -> Result<models::OrganizationUserPendingAutoConfirmResponseModelListResponseModel, Error>;
195
196 async fn get_reset_password_details<'a>(
198 &self,
199 id: uuid::Uuid,
200 org_id: &'a str,
201 organization: Option<models::Organization>,
202 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModel, Error>;
203
204 async fn invite<'a>(
206 &self,
207 org_id: uuid::Uuid,
208 organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
209 ) -> Result<(), Error>;
210
211 async fn put<'a>(
213 &self,
214 id: uuid::Uuid,
215 org_id: &'a str,
216 organization: Option<models::Organization>,
217 organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
218 ) -> Result<(), Error>;
219
220 async fn put_reset_password_enrollment<'a>(
222 &self,
223 org_id: uuid::Uuid,
224 user_id: uuid::Uuid,
225 organization_user_reset_password_enrollment_request_model: Option<
226 models::OrganizationUserResetPasswordEnrollmentRequestModel,
227 >,
228 ) -> Result<(), Error>;
229
230 async fn recover_account<'a>(
232 &self,
233 org_id: uuid::Uuid,
234 id: uuid::Uuid,
235 target_organization_user: Option<models::OrganizationUser>,
236 organization_user_reset_password_request_model: Option<
237 models::OrganizationUserResetPasswordRequestModel,
238 >,
239 ) -> Result<(), Error>;
240
241 async fn reinvite<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
243
244 async fn remove<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
246
247 async fn restore_async_v_next<'a>(
249 &self,
250 org_id: uuid::Uuid,
251 id: uuid::Uuid,
252 organization_user_restore_request: Option<models::OrganizationUserRestoreRequest>,
253 ) -> Result<(), Error>;
254
255 async fn revoke<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error>;
257
258 async fn revoke_self<'a>(&self, org_id: uuid::Uuid) -> Result<(), Error>;
260
261 async fn send_invite_to_staged_users<'a>(
264 &self,
265 org_id: uuid::Uuid,
266 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
267 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error>;
268
269 async fn user_public_keys<'a>(
271 &self,
272 org_id: uuid::Uuid,
273 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
274 ) -> Result<models::OrganizationUserPublicKeyResponseModelListResponseModel, Error>;
275}
276
277pub struct OrganizationUsersApiClient {
278 configuration: Arc<configuration::Configuration>,
279}
280
281impl OrganizationUsersApiClient {
282 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
283 Self { configuration }
284 }
285}
286
287#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
288#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
289impl OrganizationUsersApi for OrganizationUsersApiClient {
290 async fn accept<'a>(
291 &self,
292 org_id: uuid::Uuid,
293 organization_user_id: uuid::Uuid,
294 organization_user_accept_request_model: Option<models::OrganizationUserAcceptRequestModel>,
295 ) -> Result<(), Error> {
296 let local_var_configuration = &self.configuration;
297
298 let local_var_client = &local_var_configuration.client;
299
300 let local_var_uri_str = format!(
301 "{}/organizations/{orgId}/users/{organizationUserId}/accept",
302 local_var_configuration.base_path,
303 orgId = org_id,
304 organizationUserId = organization_user_id
305 );
306 let mut local_var_req_builder =
307 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
308
309 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
310 local_var_req_builder = local_var_req_builder.json(&organization_user_accept_request_model);
311
312 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
313 }
314
315 async fn accept_init<'a>(
316 &self,
317 org_id: uuid::Uuid,
318 organization_user_id: uuid::Uuid,
319 organization_user_accept_init_request_model: Option<
320 models::OrganizationUserAcceptInitRequestModel,
321 >,
322 ) -> Result<(), Error> {
323 let local_var_configuration = &self.configuration;
324
325 let local_var_client = &local_var_configuration.client;
326
327 let local_var_uri_str = format!(
328 "{}/organizations/{orgId}/users/{organizationUserId}/accept-init",
329 local_var_configuration.base_path,
330 orgId = org_id,
331 organizationUserId = organization_user_id
332 );
333 let mut local_var_req_builder =
334 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
335
336 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
337 local_var_req_builder =
338 local_var_req_builder.json(&organization_user_accept_init_request_model);
339
340 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
341 }
342
343 async fn accept_invite_link<'a>(
344 &self,
345 accept_organization_invite_link_request_model: Option<
346 models::AcceptOrganizationInviteLinkRequestModel,
347 >,
348 ) -> Result<(), Error> {
349 let local_var_configuration = &self.configuration;
350
351 let local_var_client = &local_var_configuration.client;
352
353 let local_var_uri_str = format!(
354 "{}/organizations/users/invite-link/accept",
355 local_var_configuration.base_path
356 );
357 let mut local_var_req_builder =
358 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
359
360 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
361 local_var_req_builder =
362 local_var_req_builder.json(&accept_organization_invite_link_request_model);
363
364 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
365 }
366
367 async fn automatically_confirm_organization_user<'a>(
368 &self,
369 id: uuid::Uuid,
370 org_id: &'a str,
371 organization: Option<models::Organization>,
372 organization_user_confirm_request_model: Option<
373 models::OrganizationUserConfirmRequestModel,
374 >,
375 ) -> Result<(), Error> {
376 let local_var_configuration = &self.configuration;
377
378 let local_var_client = &local_var_configuration.client;
379
380 let local_var_uri_str = format!(
381 "{}/organizations/{orgId}/users/{id}/auto-confirm",
382 local_var_configuration.base_path,
383 id = id,
384 orgId = crate::apis::urlencode(org_id)
385 );
386 let mut local_var_req_builder =
387 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
388
389 if let Some(ref param_value) = organization {
390 local_var_req_builder = local_var_req_builder
391 .query(&[("organization", &serde_json::to_value(param_value)?)]);
392 }
393 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
394 local_var_req_builder =
395 local_var_req_builder.json(&organization_user_confirm_request_model);
396
397 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
398 }
399
400 async fn bulk_automatically_confirm_organization_users<'a>(
401 &self,
402 org_id: &'a str,
403 organization: Option<models::Organization>,
404 organization_user_bulk_confirm_request_model: Option<
405 models::OrganizationUserBulkConfirmRequestModel,
406 >,
407 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
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/bulk-auto-confirm",
414 local_var_configuration.base_path,
415 orgId = crate::apis::urlencode(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 if let Some(ref param_value) = organization {
421 local_var_req_builder = local_var_req_builder
422 .query(&[("organization", &serde_json::to_value(param_value)?)]);
423 }
424 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
425 local_var_req_builder =
426 local_var_req_builder.json(&organization_user_bulk_confirm_request_model);
427
428 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
429 }
430
431 async fn bulk_confirm<'a>(
432 &self,
433 org_id: uuid::Uuid,
434 organization_user_bulk_confirm_request_model: Option<
435 models::OrganizationUserBulkConfirmRequestModel,
436 >,
437 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
438 let local_var_configuration = &self.configuration;
439
440 let local_var_client = &local_var_configuration.client;
441
442 let local_var_uri_str = format!(
443 "{}/organizations/{orgId}/users/confirm",
444 local_var_configuration.base_path,
445 orgId = org_id
446 );
447 let mut local_var_req_builder =
448 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
449
450 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
451 local_var_req_builder =
452 local_var_req_builder.json(&organization_user_bulk_confirm_request_model);
453
454 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
455 }
456
457 async fn bulk_delete_account<'a>(
458 &self,
459 org_id: uuid::Uuid,
460 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
461 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
462 let local_var_configuration = &self.configuration;
463
464 let local_var_client = &local_var_configuration.client;
465
466 let local_var_uri_str = format!(
467 "{}/organizations/{orgId}/users/delete-account",
468 local_var_configuration.base_path,
469 orgId = org_id
470 );
471 let mut local_var_req_builder =
472 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
473
474 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
475 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
476
477 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
478 }
479
480 async fn bulk_enable_pam<'a>(
481 &self,
482 org_id: uuid::Uuid,
483 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
484 ) -> Result<(), Error> {
485 let local_var_configuration = &self.configuration;
486
487 let local_var_client = &local_var_configuration.client;
488
489 let local_var_uri_str = format!(
490 "{}/organizations/{orgId}/users/enable-pam",
491 local_var_configuration.base_path,
492 orgId = org_id
493 );
494 let mut local_var_req_builder =
495 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
496
497 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
498 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
499
500 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
501 }
502
503 async fn bulk_enable_secrets_manager<'a>(
504 &self,
505 org_id: uuid::Uuid,
506 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
507 ) -> Result<(), Error> {
508 let local_var_configuration = &self.configuration;
509
510 let local_var_client = &local_var_configuration.client;
511
512 let local_var_uri_str = format!(
513 "{}/organizations/{orgId}/users/enable-secrets-manager",
514 local_var_configuration.base_path,
515 orgId = org_id
516 );
517 let mut local_var_req_builder =
518 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
519
520 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
521 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
522
523 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
524 }
525
526 async fn bulk_reinvite<'a>(
527 &self,
528 org_id: uuid::Uuid,
529 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
530 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
531 let local_var_configuration = &self.configuration;
532
533 let local_var_client = &local_var_configuration.client;
534
535 let local_var_uri_str = format!(
536 "{}/organizations/{orgId}/users/reinvite",
537 local_var_configuration.base_path,
538 orgId = org_id
539 );
540 let mut local_var_req_builder =
541 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
542
543 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
544 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
545
546 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
547 }
548
549 async fn bulk_remove<'a>(
550 &self,
551 org_id: uuid::Uuid,
552 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
553 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
554 let local_var_configuration = &self.configuration;
555
556 let local_var_client = &local_var_configuration.client;
557
558 let local_var_uri_str = format!(
559 "{}/organizations/{orgId}/users",
560 local_var_configuration.base_path,
561 orgId = org_id
562 );
563 let mut local_var_req_builder =
564 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
565
566 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
567 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
568
569 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
570 }
571
572 async fn bulk_restore<'a>(
573 &self,
574 org_id: uuid::Uuid,
575 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
576 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
577 let local_var_configuration = &self.configuration;
578
579 let local_var_client = &local_var_configuration.client;
580
581 let local_var_uri_str = format!(
582 "{}/organizations/{orgId}/users/restore",
583 local_var_configuration.base_path,
584 orgId = org_id
585 );
586 let mut local_var_req_builder =
587 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
588
589 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
590 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
591
592 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
593 }
594
595 async fn bulk_revoke<'a>(
596 &self,
597 org_id: uuid::Uuid,
598 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
599 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
600 let local_var_configuration = &self.configuration;
601
602 let local_var_client = &local_var_configuration.client;
603
604 let local_var_uri_str = format!(
605 "{}/organizations/{orgId}/users/revoke",
606 local_var_configuration.base_path,
607 orgId = org_id
608 );
609 let mut local_var_req_builder =
610 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
611
612 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
613 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
614
615 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
616 }
617
618 async fn confirm<'a>(
619 &self,
620 org_id: uuid::Uuid,
621 id: uuid::Uuid,
622 organization_user_confirm_request_model: Option<
623 models::OrganizationUserConfirmRequestModel,
624 >,
625 ) -> Result<(), Error> {
626 let local_var_configuration = &self.configuration;
627
628 let local_var_client = &local_var_configuration.client;
629
630 let local_var_uri_str = format!(
631 "{}/organizations/{orgId}/users/{id}/confirm",
632 local_var_configuration.base_path,
633 orgId = org_id,
634 id = id
635 );
636 let mut local_var_req_builder =
637 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
638
639 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
640 local_var_req_builder =
641 local_var_req_builder.json(&organization_user_confirm_request_model);
642
643 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
644 }
645
646 async fn confirm_invite_link<'a>(
647 &self,
648 confirm_organization_invite_link_request_model: Option<
649 models::ConfirmOrganizationInviteLinkRequestModel,
650 >,
651 ) -> Result<(), Error> {
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 "{}/organizations/users/invite-link/confirm",
658 local_var_configuration.base_path
659 );
660 let mut local_var_req_builder =
661 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
662
663 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
664 local_var_req_builder =
665 local_var_req_builder.json(&confirm_organization_invite_link_request_model);
666
667 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
668 }
669
670 async fn delete_account<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
671 let local_var_configuration = &self.configuration;
672
673 let local_var_client = &local_var_configuration.client;
674
675 let local_var_uri_str = format!(
676 "{}/organizations/{orgId}/users/{id}/delete-account",
677 local_var_configuration.base_path,
678 orgId = org_id,
679 id = id
680 );
681 let mut local_var_req_builder =
682 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
683
684 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
685
686 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
687 }
688
689 async fn get<'a>(
690 &self,
691 org_id: uuid::Uuid,
692 id: uuid::Uuid,
693 include_groups: Option<bool>,
694 ) -> Result<models::OrganizationUserDetailsResponseModel, Error> {
695 let local_var_configuration = &self.configuration;
696
697 let local_var_client = &local_var_configuration.client;
698
699 let local_var_uri_str = format!(
700 "{}/organizations/{orgId}/users/{id}",
701 local_var_configuration.base_path,
702 orgId = org_id,
703 id = id
704 );
705 let mut local_var_req_builder =
706 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
707
708 if let Some(ref param_value) = include_groups {
709 local_var_req_builder =
710 local_var_req_builder.query(&[("includeGroups", ¶m_value.to_string())]);
711 }
712 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
713
714 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
715 }
716
717 async fn get_account_recovery_details<'a>(
718 &self,
719 org_id: uuid::Uuid,
720 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
721 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModelListResponseModel, Error>
722 {
723 let local_var_configuration = &self.configuration;
724
725 let local_var_client = &local_var_configuration.client;
726
727 let local_var_uri_str = format!(
728 "{}/organizations/{orgId}/users/account-recovery-details",
729 local_var_configuration.base_path,
730 orgId = org_id
731 );
732 let mut local_var_req_builder =
733 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
734
735 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
736 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
737
738 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
739 }
740
741 async fn get_all<'a>(
742 &self,
743 org_id: uuid::Uuid,
744 include_groups: Option<bool>,
745 include_collections: Option<bool>,
746 ) -> Result<models::OrganizationUserUserDetailsResponseModelListResponseModel, Error> {
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 "{}/organizations/{orgId}/users",
753 local_var_configuration.base_path,
754 orgId = org_id
755 );
756 let mut local_var_req_builder =
757 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
758
759 if let Some(ref param_value) = include_groups {
760 local_var_req_builder =
761 local_var_req_builder.query(&[("includeGroups", ¶m_value.to_string())]);
762 }
763 if let Some(ref param_value) = include_collections {
764 local_var_req_builder =
765 local_var_req_builder.query(&[("includeCollections", ¶m_value.to_string())]);
766 }
767 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
768
769 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
770 }
771
772 async fn get_invite<'a>(
773 &self,
774 get_organization_invite_request_model: Option<models::GetOrganizationInviteRequestModel>,
775 ) -> Result<models::OrganizationInviteResponseModel, Error> {
776 let local_var_configuration = &self.configuration;
777
778 let local_var_client = &local_var_configuration.client;
779
780 let local_var_uri_str = format!(
781 "{}/organizations/users/invite-link/invite",
782 local_var_configuration.base_path
783 );
784 let mut local_var_req_builder =
785 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
786
787 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
788 local_var_req_builder = local_var_req_builder.json(&get_organization_invite_request_model);
789
790 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
791 }
792
793 async fn get_mini_details<'a>(
794 &self,
795 org_id: uuid::Uuid,
796 ) -> Result<models::OrganizationUserUserMiniDetailsResponseModelListResponseModel, Error> {
797 let local_var_configuration = &self.configuration;
798
799 let local_var_client = &local_var_configuration.client;
800
801 let local_var_uri_str = format!(
802 "{}/organizations/{orgId}/users/mini-details",
803 local_var_configuration.base_path,
804 orgId = org_id
805 );
806 let mut local_var_req_builder =
807 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
808
809 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
810
811 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
812 }
813
814 async fn get_pending_auto_confirm_users<'a>(
815 &self,
816 org_id: uuid::Uuid,
817 ) -> Result<models::OrganizationUserPendingAutoConfirmResponseModelListResponseModel, Error>
818 {
819 let local_var_configuration = &self.configuration;
820
821 let local_var_client = &local_var_configuration.client;
822
823 let local_var_uri_str = format!(
824 "{}/organizations/{orgId}/users/pending-auto-confirm",
825 local_var_configuration.base_path,
826 orgId = org_id
827 );
828 let mut local_var_req_builder =
829 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
830
831 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
832
833 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
834 }
835
836 async fn get_reset_password_details<'a>(
837 &self,
838 id: uuid::Uuid,
839 org_id: &'a str,
840 organization: Option<models::Organization>,
841 ) -> Result<models::OrganizationUserResetPasswordDetailsResponseModel, Error> {
842 let local_var_configuration = &self.configuration;
843
844 let local_var_client = &local_var_configuration.client;
845
846 let local_var_uri_str = format!(
847 "{}/organizations/{orgId}/users/{id}/reset-password-details",
848 local_var_configuration.base_path,
849 id = id,
850 orgId = crate::apis::urlencode(org_id)
851 );
852 let mut local_var_req_builder =
853 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
854
855 if let Some(ref param_value) = organization {
856 local_var_req_builder = local_var_req_builder
857 .query(&[("organization", &serde_json::to_value(param_value)?)]);
858 }
859 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
860
861 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
862 }
863
864 async fn invite<'a>(
865 &self,
866 org_id: uuid::Uuid,
867 organization_user_invite_request_model: Option<models::OrganizationUserInviteRequestModel>,
868 ) -> Result<(), Error> {
869 let local_var_configuration = &self.configuration;
870
871 let local_var_client = &local_var_configuration.client;
872
873 let local_var_uri_str = format!(
874 "{}/organizations/{orgId}/users/invite",
875 local_var_configuration.base_path,
876 orgId = org_id
877 );
878 let mut local_var_req_builder =
879 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
880
881 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
882 local_var_req_builder = local_var_req_builder.json(&organization_user_invite_request_model);
883
884 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
885 }
886
887 async fn put<'a>(
888 &self,
889 id: uuid::Uuid,
890 org_id: &'a str,
891 organization: Option<models::Organization>,
892 organization_user_update_request_model: Option<models::OrganizationUserUpdateRequestModel>,
893 ) -> Result<(), Error> {
894 let local_var_configuration = &self.configuration;
895
896 let local_var_client = &local_var_configuration.client;
897
898 let local_var_uri_str = format!(
899 "{}/organizations/{orgId}/users/{id}",
900 local_var_configuration.base_path,
901 id = id,
902 orgId = crate::apis::urlencode(org_id)
903 );
904 let mut local_var_req_builder =
905 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
906
907 if let Some(ref param_value) = organization {
908 local_var_req_builder = local_var_req_builder
909 .query(&[("organization", &serde_json::to_value(param_value)?)]);
910 }
911 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
912 local_var_req_builder = local_var_req_builder.json(&organization_user_update_request_model);
913
914 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
915 }
916
917 async fn put_reset_password_enrollment<'a>(
918 &self,
919 org_id: uuid::Uuid,
920 user_id: uuid::Uuid,
921 organization_user_reset_password_enrollment_request_model: Option<
922 models::OrganizationUserResetPasswordEnrollmentRequestModel,
923 >,
924 ) -> Result<(), Error> {
925 let local_var_configuration = &self.configuration;
926
927 let local_var_client = &local_var_configuration.client;
928
929 let local_var_uri_str = format!(
930 "{}/organizations/{orgId}/users/{userId}/reset-password-enrollment",
931 local_var_configuration.base_path,
932 orgId = org_id,
933 userId = user_id
934 );
935 let mut local_var_req_builder =
936 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
937
938 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
939 local_var_req_builder =
940 local_var_req_builder.json(&organization_user_reset_password_enrollment_request_model);
941
942 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
943 }
944
945 async fn recover_account<'a>(
946 &self,
947 org_id: uuid::Uuid,
948 id: uuid::Uuid,
949 target_organization_user: Option<models::OrganizationUser>,
950 organization_user_reset_password_request_model: Option<
951 models::OrganizationUserResetPasswordRequestModel,
952 >,
953 ) -> Result<(), Error> {
954 let local_var_configuration = &self.configuration;
955
956 let local_var_client = &local_var_configuration.client;
957
958 let local_var_uri_str = format!(
959 "{}/organizations/{orgId}/users/{id}/recover-account",
960 local_var_configuration.base_path,
961 orgId = org_id,
962 id = id
963 );
964 let mut local_var_req_builder =
965 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
966
967 if let Some(ref param_value) = target_organization_user {
968 local_var_req_builder = local_var_req_builder.query(&[(
969 "targetOrganizationUser",
970 &serde_json::to_value(param_value)?,
971 )]);
972 }
973 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
974 local_var_req_builder =
975 local_var_req_builder.json(&organization_user_reset_password_request_model);
976
977 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
978 }
979
980 async fn reinvite<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
981 let local_var_configuration = &self.configuration;
982
983 let local_var_client = &local_var_configuration.client;
984
985 let local_var_uri_str = format!(
986 "{}/organizations/{orgId}/users/{id}/reinvite",
987 local_var_configuration.base_path,
988 orgId = org_id,
989 id = id
990 );
991 let mut local_var_req_builder =
992 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
993
994 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
995
996 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
997 }
998
999 async fn remove<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
1000 let local_var_configuration = &self.configuration;
1001
1002 let local_var_client = &local_var_configuration.client;
1003
1004 let local_var_uri_str = format!(
1005 "{}/organizations/{orgId}/users/{id}",
1006 local_var_configuration.base_path,
1007 orgId = org_id,
1008 id = id
1009 );
1010 let mut local_var_req_builder =
1011 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1012
1013 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1014
1015 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1016 }
1017
1018 async fn restore_async_v_next<'a>(
1019 &self,
1020 org_id: uuid::Uuid,
1021 id: uuid::Uuid,
1022 organization_user_restore_request: Option<models::OrganizationUserRestoreRequest>,
1023 ) -> Result<(), Error> {
1024 let local_var_configuration = &self.configuration;
1025
1026 let local_var_client = &local_var_configuration.client;
1027
1028 let local_var_uri_str = format!(
1029 "{}/organizations/{orgId}/users/{id}/restore/vnext",
1030 local_var_configuration.base_path,
1031 orgId = org_id,
1032 id = id
1033 );
1034 let mut local_var_req_builder =
1035 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1036
1037 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1038 local_var_req_builder = local_var_req_builder.json(&organization_user_restore_request);
1039
1040 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1041 }
1042
1043 async fn revoke<'a>(&self, org_id: uuid::Uuid, id: uuid::Uuid) -> Result<(), Error> {
1044 let local_var_configuration = &self.configuration;
1045
1046 let local_var_client = &local_var_configuration.client;
1047
1048 let local_var_uri_str = format!(
1049 "{}/organizations/{orgId}/users/{id}/revoke",
1050 local_var_configuration.base_path,
1051 orgId = org_id,
1052 id = id
1053 );
1054 let mut local_var_req_builder =
1055 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1056
1057 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1058
1059 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1060 }
1061
1062 async fn revoke_self<'a>(&self, org_id: uuid::Uuid) -> Result<(), Error> {
1063 let local_var_configuration = &self.configuration;
1064
1065 let local_var_client = &local_var_configuration.client;
1066
1067 let local_var_uri_str = format!(
1068 "{}/organizations/{orgId}/users/revoke-self",
1069 local_var_configuration.base_path,
1070 orgId = org_id
1071 );
1072 let mut local_var_req_builder =
1073 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1074
1075 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1076
1077 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
1078 }
1079
1080 async fn send_invite_to_staged_users<'a>(
1082 &self,
1083 org_id: uuid::Uuid,
1084 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
1085 ) -> Result<models::OrganizationUserBulkResponseModelListResponseModel, Error> {
1086 let local_var_configuration = &self.configuration;
1087
1088 let local_var_client = &local_var_configuration.client;
1089
1090 let local_var_uri_str = format!(
1091 "{}/organizations/{orgId}/users/send-invite",
1092 local_var_configuration.base_path,
1093 orgId = org_id
1094 );
1095 let mut local_var_req_builder =
1096 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1097
1098 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1099 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
1100
1101 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
1102 }
1103
1104 async fn user_public_keys<'a>(
1105 &self,
1106 org_id: uuid::Uuid,
1107 organization_user_bulk_request_model: Option<models::OrganizationUserBulkRequestModel>,
1108 ) -> Result<models::OrganizationUserPublicKeyResponseModelListResponseModel, Error> {
1109 let local_var_configuration = &self.configuration;
1110
1111 let local_var_client = &local_var_configuration.client;
1112
1113 let local_var_uri_str = format!(
1114 "{}/organizations/{orgId}/users/public-keys",
1115 local_var_configuration.base_path,
1116 orgId = org_id
1117 );
1118 let mut local_var_req_builder =
1119 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1120
1121 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1122 local_var_req_builder = local_var_req_builder.json(&organization_user_bulk_request_model);
1123
1124 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
1125 }
1126}