bitwarden_api_api/apis/
accounts_key_management_api.rs1use 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 AccountsKeyManagementApi: Send + Sync {
29 async fn get_key_connector_confirmation_details<'a>(
31 &self,
32 org_sso_identifier: &'a str,
33 ) -> Result<models::KeyConnectorConfirmationDetailsResponseModel, Error>;
34
35 async fn password_change_and_rotate_user_account_keys<'a>(
37 &self,
38 rotate_user_account_keys_and_data_request_model: Option<
39 models::RotateUserAccountKeysAndDataRequestModel,
40 >,
41 ) -> Result<(), Error>;
42
43 async fn post_convert_to_key_connector(&self) -> Result<(), Error>;
45
46 async fn post_enroll_to_key_connector<'a>(
48 &self,
49 key_connector_enrollment_request_model: Option<models::KeyConnectorEnrollmentRequestModel>,
50 ) -> Result<(), Error>;
51
52 async fn post_set_key_connector_key<'a>(
54 &self,
55 set_key_connector_key_request_model: Option<models::SetKeyConnectorKeyRequestModel>,
56 ) -> Result<(), Error>;
57
58 async fn regenerate_keys<'a>(
60 &self,
61 key_regeneration_request_model: Option<models::KeyRegenerationRequestModel>,
62 ) -> Result<(), Error>;
63
64 async fn rotate_user_keys<'a>(
66 &self,
67 rotate_user_keys_request_model: Option<models::RotateUserKeysRequestModel>,
68 ) -> Result<(), Error>;
69}
70
71pub struct AccountsKeyManagementApiClient {
72 configuration: Arc<configuration::Configuration>,
73}
74
75impl AccountsKeyManagementApiClient {
76 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
77 Self { configuration }
78 }
79}
80
81#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
82#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
83impl AccountsKeyManagementApi for AccountsKeyManagementApiClient {
84 async fn get_key_connector_confirmation_details<'a>(
85 &self,
86 org_sso_identifier: &'a str,
87 ) -> Result<models::KeyConnectorConfirmationDetailsResponseModel, Error> {
88 let local_var_configuration = &self.configuration;
89
90 let local_var_client = &local_var_configuration.client;
91
92 let local_var_uri_str = format!(
93 "{}/accounts/key-connector/confirmation-details/{orgSsoIdentifier}",
94 local_var_configuration.base_path,
95 orgSsoIdentifier = crate::apis::urlencode(org_sso_identifier)
96 );
97 let mut local_var_req_builder =
98 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
99
100 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
101
102 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
103 }
104
105 async fn password_change_and_rotate_user_account_keys<'a>(
106 &self,
107 rotate_user_account_keys_and_data_request_model: Option<
108 models::RotateUserAccountKeysAndDataRequestModel,
109 >,
110 ) -> Result<(), Error> {
111 let local_var_configuration = &self.configuration;
112
113 let local_var_client = &local_var_configuration.client;
114
115 let local_var_uri_str = format!(
116 "{}/accounts/key-management/rotate-user-account-keys",
117 local_var_configuration.base_path
118 );
119 let mut local_var_req_builder =
120 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
121
122 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
123 local_var_req_builder =
124 local_var_req_builder.json(&rotate_user_account_keys_and_data_request_model);
125
126 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
127 }
128
129 async fn post_convert_to_key_connector(&self) -> Result<(), Error> {
130 let local_var_configuration = &self.configuration;
131
132 let local_var_client = &local_var_configuration.client;
133
134 let local_var_uri_str = format!(
135 "{}/accounts/convert-to-key-connector",
136 local_var_configuration.base_path
137 );
138 let mut local_var_req_builder =
139 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
140
141 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
142
143 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
144 }
145
146 async fn post_enroll_to_key_connector<'a>(
147 &self,
148 key_connector_enrollment_request_model: Option<models::KeyConnectorEnrollmentRequestModel>,
149 ) -> Result<(), Error> {
150 let local_var_configuration = &self.configuration;
151
152 let local_var_client = &local_var_configuration.client;
153
154 let local_var_uri_str = format!(
155 "{}/accounts/key-connector/enroll",
156 local_var_configuration.base_path
157 );
158 let mut local_var_req_builder =
159 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
160
161 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
162 local_var_req_builder = local_var_req_builder.json(&key_connector_enrollment_request_model);
163
164 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
165 }
166
167 async fn post_set_key_connector_key<'a>(
168 &self,
169 set_key_connector_key_request_model: Option<models::SetKeyConnectorKeyRequestModel>,
170 ) -> Result<(), Error> {
171 let local_var_configuration = &self.configuration;
172
173 let local_var_client = &local_var_configuration.client;
174
175 let local_var_uri_str = format!(
176 "{}/accounts/set-key-connector-key",
177 local_var_configuration.base_path
178 );
179 let mut local_var_req_builder =
180 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
181
182 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
183 local_var_req_builder = local_var_req_builder.json(&set_key_connector_key_request_model);
184
185 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
186 }
187
188 async fn regenerate_keys<'a>(
189 &self,
190 key_regeneration_request_model: Option<models::KeyRegenerationRequestModel>,
191 ) -> Result<(), Error> {
192 let local_var_configuration = &self.configuration;
193
194 let local_var_client = &local_var_configuration.client;
195
196 let local_var_uri_str = format!(
197 "{}/accounts/key-management/regenerate-keys",
198 local_var_configuration.base_path
199 );
200 let mut local_var_req_builder =
201 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
202
203 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
204 local_var_req_builder = local_var_req_builder.json(&key_regeneration_request_model);
205
206 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
207 }
208
209 async fn rotate_user_keys<'a>(
210 &self,
211 rotate_user_keys_request_model: Option<models::RotateUserKeysRequestModel>,
212 ) -> Result<(), Error> {
213 let local_var_configuration = &self.configuration;
214
215 let local_var_client = &local_var_configuration.client;
216
217 let local_var_uri_str = format!(
218 "{}/accounts/key-management/rotate-user-keys",
219 local_var_configuration.base_path
220 );
221 let mut local_var_req_builder =
222 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
223
224 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
225 local_var_req_builder = local_var_req_builder.json(&rotate_user_keys_request_model);
226
227 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
228 }
229}